<!DOCTYPE html>
<html lang="zh-CN">





<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="/myblog/img/apple-touch-icon.png">
  <link rel="icon" type="image/png" href="/myblog/img/favicon.png">
  <meta name="viewport"
        content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="theme-color" content="#2f4154">
  <meta name="description" content="TakCode Blog">
  <meta name="author" content="谢芃">
  <meta name="keywords" content="">
  <title>JavaScript基础学习笔记 - TakCode</title>

  <link  rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/5.12.1/css/all.min.css" />
<link  rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/4.4.1/css/bootstrap.min.css" />
<link  rel="stylesheet" href="https://cdn.staticfile.org/mdbootstrap/4.13.0/css/mdb.min.css" />
<link  rel="stylesheet" href="https://cdn.staticfile.org/github-markdown-css/3.0.1/github-markdown.min.css" />

<link rel="stylesheet" href="//at.alicdn.com/t/font_1067060_qzomjdt8bmp.css">



  <link  rel="stylesheet" href="/myblog/lib/prettify/tomorrow-night-eighties.min.css" />

<link  rel="stylesheet" href="/myblog/css/main.css" />


  <link defer rel="stylesheet" href="https://cdn.staticfile.org/fancybox/3.5.7/jquery.fancybox.min.css" />


<!-- 自定义样式保持在最底部 -->


<meta name="generator" content="Hexo 4.2.0"></head>


<body>
  <header style="height: 70vh;">
    <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand"
       href="/myblog/">&nbsp;<strong>TakCode</strong>&nbsp;</a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/myblog/">首页</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/myblog/archives/">归档</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/myblog/categories/">分类</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/myblog/tags/">标签</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/myblog/about/">关于</a>
          </li>
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" data-toggle="modal" data-target="#modalSearch">&nbsp;&nbsp;<i
                class="iconfont icon-search"></i>&nbsp;&nbsp;</a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

    <div class="view intro-2" id="background" parallax=true
         style="background: url('/myblog/img/default.png') no-repeat center center;
           background-size: cover;">
      <div class="full-bg-img">
        <div class="mask rgba-black-light flex-center">
          <div class="container text-center white-text fadeInUp">
            <span class="h2" id="subtitle">
              
            </span>

            
              
                <p class="mt-3 post-meta">
                  <i class="fas fa-calendar-alt" aria-hidden="true"></i>
                  星期日, 三月 10日 2019, 9:19 上午
                </p>
              

              <p class="mt-1">
                
                  
                  <span class="post-meta">
                    <i class="far fa-chart-bar"></i>
                    16.9k 字
                  </span>
                

                
                  
                  <span class="post-meta">
                      <i class="far fa-clock"></i>
                      62 分钟
                  </span>
                

                
              </p>
            
          </div>

          
        </div>
      </div>
    </div>
  </header>

  <main>
    
      

<div class="container-fluid">
  <div class="row">
    <div class="d-none d-lg-block col-lg-2"></div>
    <div class="col-lg-8 nopadding-md">
      <div class="container nopadding-md" id="board-ctn">
        <div class="py-5 z-depth-3" id="board">
          <div class="post-content mx-auto" id="post">
            
            <div class="markdown-body">
              <p>JavaScript</p>
<a id="more"></a>



<h3 id="浏览器执行-JS-简介"><a href="#浏览器执行-JS-简介" class="headerlink" title="浏览器执行 JS 简介"></a>浏览器执行 JS 简介</h3><p><strong>浏览器分成两部分：渲染引擎和 JS 引擎</strong></p>
<p>1.渲染引擎：<br>用来解析HTML与CSS，俗称内核，比如 chrome浏览器的 blink，老版本的 webkit<br>2.JS引擎：<br>也称为JS解释器。用来读取网页中的 javaScript代码，对其处理后运行，比如 chrome浏览器的V8</p>
<pre><code>    浏览器本身并不会执行JS代码，而是通过内置 JavaScript 引擎(解释器) 来执行 JS 代码 。JS 引擎执行代码时逐行解释每一句源码（转换为机器语言），然后由计算机去执行，所以 JavaScript 语言归为脚本语言，会逐行解释执行。</code></pre><h3 id="JS-的组成"><a href="#JS-的组成" class="headerlink" title="JS 的组成"></a>JS 的组成</h3><p><img src="http://helloxx.cn/d1img11.png" srcset="/myblog/img/loading.gif" alt=""></p>
<ol>
<li><h4 id="ECMAScript"><a href="#ECMAScript" class="headerlink" title="ECMAScript"></a><strong>ECMAScript</strong></h4><pre><code>​        ECMAScript 是由ECMA 国际（ 原欧洲计算机制造商协会）进行标准化的一门编程语言，这种语言在万维网上应用广泛，它往往被称为 JavaScript或 JScript，但实际上后两者是 ECMAScript 语言的实现和扩展。</code></pre><p><img src="http://helloxx.cn/d1img12.png" srcset="/myblog/img/loading.gif" alt=""></p>
<p>​        ECMAScript：规定了JS的编程语法和基础核心知识，是所有浏览器厂商共同遵守的一套JS语法工业标准。</p>
<p>更多参看MDN: <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/JavaScript_technologies_overview" target="_blank" rel="noopener">MDN手册</a></p>
</li>
<li><h4 id="DOM——文档对象模型"><a href="#DOM——文档对象模型" class="headerlink" title="DOM——文档对象模型"></a><strong>DOM——文档对象模型</strong></h4><pre><code>​        **文档对象模型**（DocumentObject Model，简称DOM），是W3C组织推荐的处理可扩展标记语言的标准编程接口。通过 DOM 提供的接口可以对页面上的各种元素进行操作（大小、位置、颜色等）</code></pre></li>
<li><h4 id="BOM——浏览器对象模型"><a href="#BOM——浏览器对象模型" class="headerlink" title="BOM——浏览器对象模型"></a><strong>BOM——浏览器对象模型</strong></h4><pre><code>​        **浏览器对象模型**(Browser Object Model，简称BOM) 是指浏览器对象模型，它提供了独立于内容的、可以与浏览器窗口进行互动的对象结构。通过BOM可以操作浏览器窗口，比如弹出框、控制浏览器跳转、获取分辨率等。</code></pre></li>
</ol>
<h3 id="JS-初体验"><a href="#JS-初体验" class="headerlink" title="JS 初体验"></a>JS 初体验</h3><p>JS 有3种书写位置，分别为行内、内嵌和外部。</p>
<ol>
<li><p>行内式</p>
<pre><code class="html">&lt;input type=&quot;button&quot; value=&quot;点我试试&quot; onclick=&quot;alert(&#39;Hello World&#39;)&quot; /&gt;</code></pre>
<ul>
<li>可以将单行或少量 JS 代码写在HTML标签的事件属性中（以 on 开头的属性），如：onclick</li>
<li>注意单双引号的使用：在HTML中我们推荐使用双引号, JS 中我们推荐使用单引号</li>
<li>可读性差， 在html中编写JS大量代码时，不方便阅读；</li>
<li>引号易错，引号多层嵌套匹配时，非常容易弄混；</li>
<li>特殊情况下使用</li>
</ul>
</li>
<li><p>内嵌式</p>
<pre><code class="html">&lt;script&gt;
    alert(&#39;Hello  World~!&#39;);
&lt;/script&gt;</code></pre>
<ul>
<li>可以将多行JS代码写到 script 标签中</li>
<li>内嵌 JS 是学习时常用的方式</li>
</ul>
</li>
<li><p>外部JS文件</p>
<pre><code class="html">&lt;script src=&quot;my.js&quot;&gt;&lt;/script&gt;</code></pre>
<ul>
<li>利于HTML页面代码结构化，把大段 JS代码独立到 HTML 页面之外，既美观，也方便文件级别的复用</li>
<li>引用外部 JS文件的 script 标签中间不可以写代码</li>
<li>适合于JS 代码量比较大的情况</li>
</ul>
</li>
</ol>
<h2 id="JavaScript注释"><a href="#JavaScript注释" class="headerlink" title="JavaScript注释"></a>JavaScript注释</h2><ul>
<li>flex子项目占的份数</li>
<li>align-self控制子项自己在侧轴的排列方式</li>
<li>order属性定义子项的排列顺序（前后顺序）</li>
</ul>
<h3 id="单行注释"><a href="#单行注释" class="headerlink" title="单行注释"></a>单行注释</h3><pre><code>为了提高代码的可读性，JS与CSS一样，也提供了注释功能。
JS中的注释主要有两种，分别是 单行注释 和 多行注释。</code></pre><p>单行注释的注释方式如下：</p>
<pre><code class="html">// 我是一行文字，不想被 JS引擎 执行，所以 注释起来    </code></pre>
<pre><code>// 用来注释单行文字（  快捷键   ctrl  +  /   ）</code></pre><h3 id="多行注释"><a href="#多行注释" class="headerlink" title="多行注释"></a>多行注释</h3><p>多行注释的注释方式如下：</p>
<pre><code class="html">/*
  获取用户年龄和姓名
  并通过提示框显示出来
*/</code></pre>
<pre><code>/* */  用来注释多行文字</code></pre><h2 id="JavaScript输入输出语句"><a href="#JavaScript输入输出语句" class="headerlink" title="JavaScript输入输出语句"></a>JavaScript输入输出语句</h2><p>为了方便信息的输入输出，JS中提供了一些输入输出语句，其常用的语句如下：</p>
<table>
<thead>
<tr>
<th>方法</th>
<th>说明</th>
<th>归属</th>
</tr>
</thead>
<tbody><tr>
<td>alert(msg)</td>
<td>浏览器弹出警示框</td>
<td>浏览器</td>
</tr>
<tr>
<td>console.log(msg)</td>
<td>浏览器控制台打印输出信息</td>
<td>浏览器</td>
</tr>
<tr>
<td>prompt(info)</td>
<td>浏览器弹出输入框，用户可以输入</td>
<td>浏览器</td>
</tr>
</tbody></table>
<ul>
<li>注意：alert() 主要用来显示消息给用户，console.log() 用来给程序员自己看运行时的消息。</li>
</ul>
<h2 id="变量的使用"><a href="#变量的使用" class="headerlink" title="变量的使用"></a>变量的使用</h2><ul>
<li>变量的声明   </li>
<li>变量的赋值 </li>
</ul>
<h3 id="声明变量"><a href="#声明变量" class="headerlink" title="声明变量"></a>声明变量</h3><pre><code class="javascript">//  声明变量  
var age; //  声明一个 名称为age 的变量     </code></pre>
<ul>
<li><p>var 是一个 JS关键字，用来声明变量( variable 变量的意思 )。使用该关键字声明变量后，计算机会自动为变量分配内存空间，不需要程序员管</p>
</li>
<li><p>age 是程序员定义的变量名，我们要通过变量名来访问内存中分配的空间</p>
</li>
</ul>
<h3 id="赋值"><a href="#赋值" class="headerlink" title="赋值"></a>赋值</h3><pre><code class="javascript">age = 10; // 给 age  这个变量赋值为 10          </code></pre>
<ul>
<li>= 用来把右边的值赋给左边的变量空间中   此处代表赋值的意思</li>
<li>变量值是程序员保存到变量空间里的值</li>
</ul>
<h3 id="变量的初始化"><a href="#变量的初始化" class="headerlink" title="变量的初始化"></a>变量的初始化</h3><pre><code class="js">var age  = 18;  // 声明变量同时赋值为 18
// 声明一个变量并赋值， 我们称之为变量的初始化。</code></pre>
<h3 id="变量语法扩展"><a href="#变量语法扩展" class="headerlink" title="变量语法扩展"></a>变量语法扩展</h3><ul>
<li><p>更新变量</p>
<p>​        一个变量被重新复赋值后，它原有的值就会被覆盖，变量值将以最后一次赋的值为准。</p>
<pre><code class="js">var age = 18;

age = 81;   // 最后的结果就是81因为18 被覆盖掉了          </code></pre>
</li>
<li><p>同时声明多个变量</p>
<p>​        同时声明多个变量时，只需要写一个 var， 多个变量名之间使用英文逗号隔开。</p>
<pre><code class="js">var age = 10,  name = &#39;zs&#39;, sex = 2;       </code></pre>
</li>
<li><p>声明变量特殊情况</p>
<table>
<thead>
<tr>
<th>情况</th>
<th>说明</th>
<th>结果</th>
</tr>
</thead>
<tbody><tr>
<td>var  age ; console.log (age);</td>
<td>只声明 不赋值</td>
<td>undefined</td>
</tr>
<tr>
<td>console.log(age)</td>
<td>不声明 不赋值  直接使用</td>
<td>报错</td>
</tr>
<tr>
<td>age   = 10; console.log (age);</td>
<td>不声明   只赋值</td>
<td>10</td>
</tr>
</tbody></table>
</li>
</ul>
<h3 id="变量命名规范"><a href="#变量命名规范" class="headerlink" title="变量命名规范"></a>变量命名规范</h3><p>规则：</p>
<ul>
<li>由字母(A-Za-z)、数字(0-9)、下划线(_)、美元符号( $ )组成，如：usrAge, num01, _name</li>
<li>严格区分大小写。var app; 和 var App; 是两个变量</li>
<li>不能 以数字开头。  18age   是错误的</li>
<li>不能 是关键字、保留字。例如：var、for、while</li>
<li>变量名必须有意义。 MMD   BBD        nl   →     age  </li>
<li>遵守驼峰命名法。首字母小写，后面单词的首字母需要大写。myFirstName</li>
</ul>
<h3 id="变量提升"><a href="#变量提升" class="headerlink" title="变量提升"></a>变量提升</h3><p> 解析器会先解析代码，然后把声明的变量的声明提升到最前，这就叫做变量提升。 </p>
<pre><code>console.log(a); //undefined
var a = 1;
console.log(a);  //1</code></pre><h2 id="数据类型"><a href="#数据类型" class="headerlink" title="数据类型"></a>数据类型</h2><h3 id="数据类型简介"><a href="#数据类型简介" class="headerlink" title="数据类型简介"></a>数据类型简介</h3><ul>
<li><p>变量的数据类型</p>
<pre><code>​        变量是用来存储值的所在处，它们有名字和数据类型。变量的数据类型决定了如何将代表这些值的位存储到计算机的内存中。JavaScript 是一种弱类型或者说动态语言。这意味着不用提前声明变量的类型，在程序运行过程中，类型会被自动确定：</code></pre><pre><code class="js">var age = 10;        // 这是一个数字型
var areYouOk = &#39;是的&#39;;   // 这是一个字符串     </code></pre>
<p>​        在代码运行时，变量的数据类型是由 JS引擎 根据 = 右边变量值的数据类型来判断 的，运行完毕之后， 变量就确定了数据类型。JavaScript 拥有动态类型，同时也意味着相同的变量可用作不同的类型：</p>
<pre><code class="js">var x = 6;           // x 为数字
var x = &quot;Bill&quot;;      // x 为字符串    </code></pre>
</li>
</ul>
<h3 id="简单数据类型"><a href="#简单数据类型" class="headerlink" title="简单数据类型"></a>简单数据类型</h3><p>简单数据类型（基本数据类型）</p>
<p>JavaScript 中的简单数据类型及其说明如下：</p>
<table>
<thead>
<tr>
<th>简单数据类型</th>
<th>说明</th>
<th>默认值</th>
</tr>
</thead>
<tbody><tr>
<td>Number</td>
<td>数字型，包含整形和浮点型，如21 、0.21</td>
<td>0</td>
</tr>
<tr>
<td>Boolean</td>
<td>布尔值类型，只有true和false，等价于1和0</td>
<td>false</td>
</tr>
<tr>
<td>String</td>
<td>字符串类型，JS中，字符串都带引号</td>
<td>“”</td>
</tr>
<tr>
<td>Undefined</td>
<td>var a; 声明了变量a，但没有赋值，此时a = undefined</td>
<td>undefined</td>
</tr>
<tr>
<td>Null</td>
<td>var a = null; 声明变量 a 为空值</td>
<td>null</td>
</tr>
</tbody></table>
<p><strong>数字型 Number</strong></p>
<p>​        JavaScript 数字类型既可以保存整数，也可以保存小数(浮点数）。  </p>
<pre><code class="js">var age = 21;       // 整数
var Age = 21.3747;  // 小数     </code></pre>
<ol>
<li><p>数字型进制</p>
<p>最常见的进制有二进制、八进制、十进制、十六进制。</p>
<pre><code class="js">  // 1.八进制数字序列范围：0~7
 var num1 = 07;   // 对应十进制的7
 var num2 = 019;  // 对应十进制的19
 var num3 = 08;   // 对应十进制的8
  // 2.十六进制数字序列范围：0~9以及A~F
 var num = 0xA;   </code></pre>
<p>现阶段我们只需要记住，在JS中八进制前面加0，十六进制前面加 0x  </p>
</li>
<li><p>数字型范围</p>
<p>JavaScript中数值的最大和最小值</p>
<ul>
<li><p>最大值：Number.MAX_VALUE，这个值为： 1.7976931348623157e+308</p>
</li>
<li><p>最小值：Number.MIN_VALUE，这个值为：5e-32</p>
</li>
</ul>
</li>
<li><p>数字型三个特殊值</p>
<ul>
<li><p>Infinity ，代表无穷大，大于任何数值</p>
</li>
<li><p>-Infinity ，代表无穷小，小于任何数值</p>
</li>
<li><p>NaN ，Not a number，代表一个非数值</p>
</li>
</ul>
<ol start="4">
<li><p>isNaN</p>
<p>用来判断一个变量是否为非数字的类型，返回 true 或者 false</p>
</li>
</ol>
<p><img src="http://helloxx.cn/d1img17.png" srcset="/myblog/img/loading.gif" alt=""></p>
<pre><code class="js">var usrAge = 21;
var isOk = isNaN(userAge);
console.log(isNum);          // false ，21 不是一个非数字
var usrName = &quot;andy&quot;;
console.log(isNaN(userName));// true ，&quot;andy&quot;是一个非数字</code></pre>
</li>
</ol>
<p><strong>字符串型 String</strong></p>
<p>​        字符串型可以是引号中的任意文本，其语法为 双引号 “” 和 单引号’’</p>
<pre><code class="js">var strMsg = &quot;我爱北京天安门~&quot;;  // 使用双引号表示字符串
var strMsg2 = &#39;我爱吃猪蹄~&#39;;    // 使用单引号表示字符串
// 常见错误
var strMsg3 = 我爱大肘子;       // 报错，没使用引号，会被认为是js代码，但js没有这些语法</code></pre>
<p>​        因为 HTML 标签里面的属性使用的是双引号，JS 这里我们更推荐使用单引号。</p>
<ol>
<li><p>字符串引号嵌套</p>
<p>​        JS 可以用单引号嵌套双引号 ，或者用双引号嵌套单引号 (外双内单，外单内双)</p>
<pre><code class="js">var strMsg = &#39;我是&quot;高帅富&quot;程序猿&#39;;   // 可以用&#39;&#39;包含&quot;&quot;
var strMsg2 = &quot;我是&#39;高帅富&#39;程序猿&quot;;  // 也可以用&quot;&quot; 包含&#39;&#39;
//  常见错误
var badQuotes = &#39;What on earth?&quot;; // 报错，不能 单双引号搭配</code></pre>
</li>
<li><p>字符串转义符</p>
<p>​        类似HTML里面的特殊字符，字符串中也有特殊字符，我们称之为转义符。</p>
<p>​        转义符都是 \ 开头的，常用的转义符及其说明如下：</p>
<table>
<thead>
<tr>
<th>转义符</th>
<th>解释说明</th>
</tr>
</thead>
<tbody><tr>
<td>\n</td>
<td>换行符，n   是   newline   的意思</td>
</tr>
<tr>
<td>\ \</td>
<td>斜杠   \</td>
</tr>
<tr>
<td>&#39;</td>
<td>‘   单引号</td>
</tr>
<tr>
<td>&quot;</td>
<td>”双引号</td>
</tr>
<tr>
<td>\t</td>
<td>tab  缩进</td>
</tr>
<tr>
<td>\b</td>
<td>空格 ，b   是   blank  的意思</td>
</tr>
</tbody></table>
</li>
<li><p>字符串长度</p>
<pre><code>​        字符串是由若干字符组成的，这些字符的数量就是字符串的长度。通过字符串的 length 属性可以获取整个字符串的长度。</code></pre><pre><code class="js">var strMsg = &quot;我是帅气多金的程序猿！&quot;;
alert(strMsg.length); // 显示 11</code></pre>
</li>
<li><p>字符串拼接</p>
<ul>
<li><p>多个字符串之间可以使用 + 进行拼接，其拼接方式为 字符串 + 任何类型 = 拼接之后的新字符串</p>
</li>
<li><p>拼接前会把与字符串相加的任何类型转成字符串，再拼接成一个新的字符串</p>
<pre><code class="js">//1.1 字符串 &quot;相加&quot;
alert(&#39;hello&#39; + &#39; &#39; + &#39;world&#39;); // hello world
//1.2 数值字符串 &quot;相加&quot;
alert(&#39;100&#39; + &#39;100&#39;); // 100100
//1.3 数值字符串 + 数值
alert(&#39;11&#39; + 12);     // 1112 </code></pre>
<ul>
<li><strong><em>+ 号总结口诀：数值相加 ，字符相连</em></strong></li>
</ul>
</li>
</ul>
</li>
<li><p>字符串拼接加强</p>
<pre><code class="js">console.log(&#39;pink老师&#39; + 18);        // 只要有字符就会相连 
var age = 18;
console.log(&#39;pink老师age岁啦&#39;);      // 这样不行哦
console.log(&#39;pink老师&#39; + age);         // pink老师18
console.log(&#39;pink老师&#39; + age + &#39;岁啦&#39;); // pink老师18岁啦</code></pre>
<ul>
<li>经常会将字符串和变量来拼接，变量可以很方便地修改里面的值</li>
<li>变量是不能添加引号的，因为加引号的变量会变成字符串</li>
<li>如果变量两侧都有字符串拼接，口诀“引引加加 ”，删掉数字，变量写加中间</li>
</ul>
</li>
</ol>
<p><strong>布尔型Boolean</strong></p>
<p>​        布尔类型有两个值：true 和 false ，其中 true 表示真（对），而 false 表示假（错）。</p>
<p>​        布尔型和数字型相加的时候， true 的值为 1 ，false 的值为 0。</p>
<pre><code class="js">console.log(true + 1);  // 2
console.log(false + 1); // 1</code></pre>
<p><strong>Undefined和 Null</strong></p>
<p>​        一个声明后没有被赋值的变量会有一个默认值undefined ( 如果进行相连或者相加时，注意结果）</p>
<pre><code class="js">var variable;
console.log(variable);           // undefined
console.log(&#39;你好&#39; + variable);  // 你好undefined
console.log(11 + variable);     // NaN
console.log(true + variable);   //  NaN</code></pre>
<p>​        一个声明变量给 null 值，里面存的值为空（学习对象时，我们继续研究null)</p>
<pre><code class="js">var vari = null;
console.log(&#39;你好&#39; + vari);  // 你好null
console.log(11 + vari);     // 11
console.log(true + vari);   //  1</code></pre>
<h3 id="获取变量数据类型"><a href="#获取变量数据类型" class="headerlink" title="获取变量数据类型"></a>获取变量数据类型</h3><p><code>typeof</code> 可用来获取检测变量的数据类型</p>
<pre><code class="js">var num = 18;
console.log(typeof num) // 结果 number      </code></pre>
<p>​        不同类型的返回值</p>
<table>
<thead>
<tr>
<th>类型</th>
<th>例</th>
<th>结果</th>
</tr>
</thead>
<tbody><tr>
<td>String</td>
<td>typeof ‘Hello’</td>
<td>“string”</td>
</tr>
<tr>
<td>Number</td>
<td>typeof 18</td>
<td>“number”</td>
</tr>
<tr>
<td>Boolean</td>
<td>typeof true</td>
<td>“boolean”</td>
</tr>
<tr>
<td>Undefined</td>
<td>typeof undefined</td>
<td>“undefined”</td>
</tr>
<tr>
<td>Null</td>
<td>typeof null</td>
<td>“object”</td>
</tr>
</tbody></table>
<p><strong>字面量</strong></p>
<p>​        字面量是在源代码中一个固定值的表示法，通俗来说，就是字面量表示如何表达这个值。</p>
<ul>
<li>数字字面量：8, 9, 10</li>
<li>字符串字面量：’黑马程序员’, “大前端”</li>
<li>布尔字面量：true，false</li>
</ul>
<h3 id="数据类型转换"><a href="#数据类型转换" class="headerlink" title="数据类型转换"></a>数据类型转换</h3><p>​        什么是数据类型转换？</p>
<p>​        使用表单、prompt 获取过来的数据默认是字符串类型的，此时就不能直接简单的进行加法运算，而需要转换变量的数据类型。通俗来说，就是把一种数据类型的变量转换成另一种数据类型，通常会实现3种方式的转换：</p>
<pre><code>转换为字符串类型
转换为数字型
转换为布尔型</code></pre><ul>
<li><p>转换为字符串</p>
<table>
<thead>
<tr>
<th>方式</th>
<th>说明</th>
<th>案例</th>
</tr>
</thead>
<tbody><tr>
<td>toString()</td>
<td>转成字符串</td>
<td>var num=1;console.log(num.toSring());</td>
</tr>
<tr>
<td>String()</td>
<td>强制转换成字符串</td>
<td>var num=1;console.log(String(num));</td>
</tr>
<tr>
<td>加号拼接字符串</td>
<td>和字符串拼接结果都是字符串</td>
<td>var num=1;console.log(num+’’);</td>
</tr>
</tbody></table>
<ul>
<li>toString() 和 String()  使用方式不一样。</li>
<li>三种转换方式，更多第三种加号拼接字符串转换方式， 这一种方式也称之为隐式转换。</li>
</ul>
</li>
<li><p>转换为数字型（重点）</p>
<table>
<thead>
<tr>
<th>方式</th>
<th>说明</th>
<th>案例</th>
</tr>
</thead>
<tbody><tr>
<td>parseInt()</td>
<td>将string类型转成整数型</td>
<td>parseInt(‘78’)</td>
</tr>
<tr>
<td>parseFloat()</td>
<td>将string类型转成浮点型</td>
<td>parseFloat(‘78.21’)</td>
</tr>
<tr>
<td>Number()</td>
<td>将string类型转换成数值型</td>
<td>Number(‘12’)</td>
</tr>
<tr>
<td>js隐式转换( -  *  / )</td>
<td>利用算术运算隐式转换为数值型</td>
<td>‘12’  - 0</td>
</tr>
</tbody></table>
<ul>
<li>注意 parseInt 和 parseFloat 单词的大小写，这2个是重点</li>
<li>隐式转换是我们在进行算数运算的时候，JS 自动转换了数据类型</li>
</ul>
</li>
<li><p>转换为布尔型</p>
<table>
<thead>
<tr>
<th>方式</th>
<th>说明</th>
<th>案例</th>
</tr>
</thead>
<tbody><tr>
<td>Boolean()</td>
<td>其他类型转布尔值</td>
<td>Boolean(‘1’)</td>
</tr>
</tbody></table>
<ul>
<li><p>代表空、否定的值会被转换为 false  ，如 ‘’、0、NaN、null、undefined  </p>
</li>
<li><p>其余值都会被转换为 true</p>
<pre><code class="js">console.log(Boolean(&#39;&#39;)); // false
console.log(Boolean(0)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean(&#39;小白&#39;)); // true
console.log(Boolean(12)); // true</code></pre>
</li>
</ul>
</li>
</ul>
<h2 id="解释型语言和编译型语言"><a href="#解释型语言和编译型语言" class="headerlink" title="解释型语言和编译型语言"></a>解释型语言和编译型语言</h2><h3 id="概述"><a href="#概述" class="headerlink" title="概述"></a>概述</h3><pre><code>计算机不能直接理解任何除机器语言以外的语言，所以必须要把程序员所写的程序语言翻译成机器语言才能执行程序。程序语言翻译成机器语言的工具，被称为翻译器。</code></pre><p><img src="http://helloxx.cn/d1img22.png" srcset="/myblog/img/loading.gif" alt=""></p>
<ul>
<li>翻译器翻译的方式有两种：一个是编译，另外一个是解释。两种方式之间的区别在于翻译的时间点不同</li>
<li>编译器是在代码执行之前进行编译，生成中间代码文件</li>
<li>解释器是在运行时进行及时解释，并立即执行(当编译器以解释方式运行的时候，也称之为解释器)</li>
</ul>
<h3 id="执行过程"><a href="#执行过程" class="headerlink" title="执行过程"></a>执行过程</h3><p><img src="http://helloxx.cn/d1img23.png" srcset="/myblog/img/loading.gif" alt=""></p>
<pre><code class="vb">类似于吃饭：

    编译语言：首先把所有菜做好，才能上桌吃饭

    解释语言：好比吃火锅，边吃边涮，同时进行</code></pre>
<h2 id="关键字和保留字"><a href="#关键字和保留字" class="headerlink" title="关键字和保留字"></a>关键字和保留字</h2><h3 id="标识符"><a href="#标识符" class="headerlink" title="标识符"></a>标识符</h3><pre><code>标识(zhi)符：就是指开发人员为变量、属性、函数、参数取的名字。

标识符不能是关键字或保留字。</code></pre><h3 id="关键字"><a href="#关键字" class="headerlink" title="关键字"></a>关键字</h3><pre><code>关键字：是指JS本身已经使用了的字，不能再用它们充当变量名、方法名。

包括：break、case、catch、continue、default、delete、do、else、finally、for、function、if、in、instanceof、new、return、switch、this、throw、try、typeof、var、void、while、with 等。</code></pre><h3 id="保留字"><a href="#保留字" class="headerlink" title="保留字"></a>保留字</h3><pre><code>保留字：实际上就是预留的“关键字”，意思是现在虽然还不是关键字，但是未来可能会成为关键字，同样不能使用它们当变量名或方法名。

包括：boolean、byte、char、class、const、debugger、double、enum、export、extends、fimal、float、goto、implements、import、int、interface、long、mative、package、private、protected、public、short、static、super、synchronized、throws、transient、volatile 等。

注意：如果将保留字用作变量名或函数名，那么除非将来的浏览器实现了该保留字，否则很可能收不到任何错误消息。当浏览器将其实现后，该单词将被看做关键字，如此将出现关键字错误。</code></pre><h2 id="运算符（操作符）"><a href="#运算符（操作符）" class="headerlink" title="运算符（操作符）"></a>运算符（操作符）</h2><h3 id="运算符的分类"><a href="#运算符的分类" class="headerlink" title="运算符的分类"></a>运算符的分类</h3><p><strong>运算符</strong>（operator）也被称为操作符，是用于实现赋值、比较和执行算数运算等功能的符号。</p>
<ul>
<li>算数运算符</li>
<li>递增和递减运算符</li>
<li>比较运算符</li>
<li>逻辑运算符</li>
<li>赋值运算符</li>
</ul>
<h3 id="算数运算符"><a href="#算数运算符" class="headerlink" title="算数运算符"></a>算数运算符</h3><ul>
<li><p>算术运算符概述</p>
<p>概念：算术运算使用的符号，用于执行两个变量或值的算术运算。</p>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>实例</th>
</tr>
</thead>
<tbody><tr>
<td>+</td>
<td>加</td>
<td>10 + 20 = 30</td>
</tr>
<tr>
<td>-</td>
<td>减</td>
<td>10 - 20 = -10</td>
</tr>
<tr>
<td>*</td>
<td>乘</td>
<td>10 * 20 = 200</td>
</tr>
<tr>
<td>/</td>
<td>除</td>
<td>10 / 20 = 0.5</td>
</tr>
<tr>
<td>%</td>
<td>取余数（取模）</td>
<td>返回除法的余数 9 % 2 = 1</td>
</tr>
</tbody></table>
</li>
<li><p>浮点数的精度问题</p>
<p>浮点数值的最高精度是 17 位小数，但在进行算术计算时其精确度远远不如整数。</p>
<pre><code class="js">var result = 0.1 + 0.2;    // 结果不是 0.3，而是：0.30000000000000004
console.log(0.07 * 100);   // 结果不是 7，  而是：7.000000000000001</code></pre>
<p>所以：不要直接判断两个浮点数是否相等 ! </p>
</li>
<li><p>表达式和返回值</p>
<p>表达式：是由数字、运算符、变量等以能求得数值的有意义排列方法所得的组合</p>
<p>简单理解：是由数字、运算符、变量等组成的式子</p>
<p>表达式最终都会有一个结果，返回给开发者，称为返回值</p>
</li>
</ul>
<h3 id="递增和递减运算符"><a href="#递增和递减运算符" class="headerlink" title="递增和递减运算符"></a>递增和递减运算符</h3><ul>
<li><p>递增和递减运算符概述</p>
<pre><code>如果需要反复给数字变量添加或减去1，可以使用递增（++）和递减（ -- ）运算符来完成。

  在 JavaScript 中，递增（++）和递减（ -- ）既可以放在变量前面，也可以放在变量后面。放在变量前面时，我们可以称为前置递增（递减）运算符，放在变量后面时，我们可以称为后置递增（递减）运算符。

  注意：递增和递减运算符必须和变量配合使用。 </code></pre></li>
<li><p>递增运算符</p>
<ul>
<li><p>前置递增运算符</p>
<p>  ++num 前置递增，就是自加1，类似于 num =  num + 1，但是 ++num 写起来更简单。</p>
<p>  使用口诀：先自加，后返回值</p>
</li>
</ul>
<pre><code class="js">var  num = 10;
alert(++num + 10);   // 21</code></pre>
<ul>
<li><p>后置递增运算符</p>
<p>num++ 后置递增，就是自加1，类似于 num =  num + 1 ，但是 num++ 写起来更简单。</p>
<p>使用口诀：先返回原值，后自加 </p>
</li>
</ul>
<pre><code class="js">var  num = 10;
alert(10 + num++);  // 20</code></pre>
</li>
</ul>
<h3 id="比较运算符"><a href="#比较运算符" class="headerlink" title="比较运算符"></a>比较运算符</h3><ul>
<li><p>比较运算符概述</p>
<p>概念：比较运算符（关系运算符）是两个数据进行比较时所使用的运算符，比较运算后，会返回一个布尔值（true / false）作为比较运算的结果。</p>
<table>
<thead>
<tr>
<th>运算符名称</th>
<th>说明</th>
<th>案例</th>
<th>结果</th>
</tr>
</thead>
<tbody><tr>
<td>&lt;</td>
<td>小于号</td>
<td>1 &lt; 2</td>
<td>true</td>
</tr>
<tr>
<td>&gt;</td>
<td>大于号</td>
<td>1 &gt; 2</td>
<td>false</td>
</tr>
<tr>
<td>&gt;=</td>
<td>大于等于号（大于或者等于）</td>
<td>2 &gt;= 2</td>
<td>true</td>
</tr>
<tr>
<td>&lt;=</td>
<td>小于等于号（小于或者等于）</td>
<td>3 &lt;= 2</td>
<td>false</td>
</tr>
<tr>
<td>==</td>
<td>判等号（会转型）</td>
<td>37 == 37</td>
<td>true</td>
</tr>
<tr>
<td>!=</td>
<td>不等号</td>
<td>37 != 37</td>
<td>false</td>
</tr>
<tr>
<td>===    !==</td>
<td>全等要求值和数据类型都一致</td>
<td>37 === ‘37’</td>
<td>false</td>
</tr>
</tbody></table>
</li>
<li><p>等号比较</p>
<table>
<thead>
<tr>
<th>符号</th>
<th>作用</th>
<th>用法</th>
</tr>
</thead>
<tbody><tr>
<td>=</td>
<td>赋值</td>
<td>把右边给左边</td>
</tr>
<tr>
<td>==</td>
<td>判断</td>
<td>判断两边值是否相等</td>
</tr>
<tr>
<td>===</td>
<td>全等</td>
<td>判断两边值和数据类型是否完全相同</td>
</tr>
</tbody></table>
<pre><code class="js">console.log(18 == &#39;18&#39;); true
console.log(18 === &#39;18&#39;);  false</code></pre>
</li>
</ul>
<h3 id="逻辑运算符"><a href="#逻辑运算符" class="headerlink" title="逻辑运算符"></a>逻辑运算符</h3><ul>
<li><p>逻辑运算符概述</p>
<p>概念：逻辑运算符是用来进行布尔值运算的运算符，其返回值也是布尔值。后面开发中经常用于多个条件的判断</p>
<table>
<thead>
<tr>
<th>逻辑运算符</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>&amp;&amp;</td>
<td>“逻辑与”，简称“与” and</td>
</tr>
<tr>
<td>||</td>
<td>“逻辑或”，简称“或” or</td>
</tr>
<tr>
<td>!</td>
<td>“逻辑非”，简称“非” not</td>
</tr>
</tbody></table>
</li>
<li><p>逻辑与&amp;&amp;</p>
<p>两边都是 true才返回 true，否则返回 false</p>
</li>
</ul>
<p>  ​                <img src="http://helloxx.cn/d2img5.png" srcset="/myblog/img/loading.gif" alt=""></p>
<p>  ​                <img src="http://helloxx.cn/d2img6.png" srcset="/myblog/img/loading.gif" alt=""></p>
<ul>
<li><p>逻辑或 ||</p>
<p>两边都是 true才返回 true，否则返回 false</p>
</li>
</ul>
<p>  ​                <img src="http://helloxx.cn/d2img7.png" srcset="/myblog/img/loading.gif" alt=""></p>
<p>  ​                <img src="http://helloxx.cn/d2img8.png" srcset="/myblog/img/loading.gif" alt=""></p>
<ul>
<li><p>逻辑非 ！</p>
<p>逻辑非（!）也叫作取反符，用来取一个布尔值相反的值，如 true 的相反值是 false</p>
<pre><code class="js">var isOk = !true;
console.log(isOk);  // false</code></pre>
</li>
<li><p>短路运算（逻辑中断）</p>
<p> 短路运算的原理：当有多个表达式（值）时,左边的表达式值可以确定结果时,就不再继续运算右边的表达式的值;</p>
<ul>
<li><p>逻辑与</p>
<p>  语法： 表达式1 &amp;&amp; 表达式2</p>
<pre><code>  - 如果第一个表达式的值为真，则返回表达式2

  - 如果第一个表达式的值为假，则返回表达式1</code></pre><pre><code class="js">  console.log( 123 &amp;&amp; 456 );        // 456
  console.log( 0 &amp;&amp; 456 );          // 0
  console.log( 123 &amp;&amp; 456&amp;&amp; 789 );  // 789</code></pre>
</li>
<li><p>逻辑或</p>
<p> 语法： 表达式1 || 表达式2</p>
<pre><code> - 如果第一个表达式的值为真，则返回表达式1

 - 如果第一个表达式的值为假，则返回表达式2</code></pre><pre><code class="js">  console.log( 123 || 456 );         //  123
  console.log( 0 ||  456 );          //  456
  console.log( 123 || 456 || 789 );  //  123</code></pre>
</li>
</ul>
</li>
</ul>
<h3 id="赋值运算符"><a href="#赋值运算符" class="headerlink" title="赋值运算符"></a>赋值运算符</h3><pre><code>概念：用来把数据赋值给变量的运算符。</code></pre><table>
<thead>
<tr>
<th>赋值运算符</th>
<th>说明</th>
<th>案例</th>
</tr>
</thead>
<tbody><tr>
<td>=</td>
<td>直接赋值</td>
<td>var usrName=’Hello’;</td>
</tr>
<tr>
<td>+=、-=</td>
<td>加、减一个数后 再赋值</td>
<td>var age = 10; age+=5; // 15</td>
</tr>
<tr>
<td>*=、 /= 、%=</td>
<td>乘、除、取模后 再赋值</td>
<td>var age = 2; age*=5; // 10</td>
</tr>
</tbody></table>
<pre><code class="js">var age = 10;
age += 5;  // 相当于 age = age + 5;
age -= 5;  // 相当于 age = age - 5;
age *= 10; // 相当于 age = age * 10;</code></pre>
<h3 id="运算符优先级"><a href="#运算符优先级" class="headerlink" title="运算符优先级"></a>运算符优先级</h3><table>
<thead>
<tr>
<th>优先级</th>
<th>运算符</th>
<th>顺序</th>
</tr>
</thead>
<tbody><tr>
<td>1</td>
<td>小括号</td>
<td>()</td>
</tr>
<tr>
<td>2</td>
<td>一元运算符</td>
<td>++  –   !</td>
</tr>
<tr>
<td>3</td>
<td>算数运算符</td>
<td>先*  /  %  后 + -</td>
</tr>
<tr>
<td>4</td>
<td>关系运算符</td>
<td><strong>&gt;  &gt;=  &lt;  &lt;=</strong></td>
</tr>
<tr>
<td>5</td>
<td>相等运算符</td>
<td>==   !=   ===   !==</td>
</tr>
<tr>
<td>6</td>
<td>逻辑运算符</td>
<td>先 &amp;&amp; 后 ||</td>
</tr>
<tr>
<td>7</td>
<td>赋值运算符</td>
<td>=</td>
</tr>
<tr>
<td>8</td>
<td>逗号运算符</td>
<td>,</td>
</tr>
</tbody></table>
<ul>
<li>一元运算符里面的逻辑非优先级很高</li>
<li>逻辑与比逻辑或优先级高</li>
</ul>
<h2 id="流程控制"><a href="#流程控制" class="headerlink" title="流程控制"></a>流程控制</h2><h3 id="流程控制概念"><a href="#流程控制概念" class="headerlink" title="流程控制概念"></a>流程控制概念</h3><pre><code>在一个程序执行的过程中，各条代码的执行顺序对程序的结果是有直接影响的。很多时候我们要通过控制代码的执行顺序来实现我们要完成的功能。

简单理解：**流程控制就是来控制代码按照一定结构顺序来执行**

流程控制主要有三种结构，分别是**顺序结构**、**分支结构**和**循环结构**，代表三种代码执行的顺序。</code></pre><p><img src="http://helloxx.cn/d2img11.png" srcset="/myblog/img/loading.gif" alt=""></p>
<h3 id="顺序流程控制"><a href="#顺序流程控制" class="headerlink" title="顺序流程控制"></a>顺序流程控制</h3><p>​    </p>
<p>​    顺序结构是程序中最简单、最基本的流程控制，它没有特定的语法结构，程序会按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。<br>​                <img src="http://helloxx.cn/d2img12.png" srcset="/myblog/img/loading.gif" alt=""></p>
<h3 id="分支流程控制"><a href="#分支流程控制" class="headerlink" title="分支流程控制"></a>分支流程控制</h3><ul>
<li><p>分支结构</p>
<p>由上到下执行代码的过程中，根据不同的条件，执行不同的路径代码（执行代码多选一的过程），从而得到不同的结果</p>
<pre><code>            &lt;img src=&quot;http://helloxx.cn/d2img13.png&quot; alt=&quot;&quot;&gt;</code></pre><p>  JS 语言提供了两种分支结构语句：if 语句、switch 语句</p>
</li>
<li><p>if 语句</p>
<ul>
<li>语法结构</li>
</ul>
<pre><code class="js">// 条件成立执行代码，否则什么也不做
if (条件表达式) {
    // 条件成立执行的代码语句
}</code></pre>
<pre><code>语句可以理解为一个行为，循环语句和分支语句就是典型的语句。一个程序由很多个语句组成，一般情况下，会分割成一个一个的语句。</code></pre><ul>
<li><p>执行流程</p>
<p><img src="http://helloxx.cn/d2img14.png" srcset="/myblog/img/loading.gif" alt=""></p>
</li>
</ul>
</li>
<li><p>if else语句（双分支语句）</p>
<ul>
<li><p>语法结构</p>
<pre><code class="js">// 条件成立  执行 if 里面代码，否则执行else 里面的代码
if (条件表达式) {
    // [如果] 条件成立执行的代码
} else {
    // [否则] 执行的代码
}</code></pre>
</li>
</ul>
</li>
<li><p>执行流程</p>
<p><img src="http://helloxx.cn/d2img15.png" srcset="/myblog/img/loading.gif" alt=""></p>
</li>
<li><p>if else if 语句(多分支语句)</p>
<ul>
<li><p>语法结构</p>
<pre><code class="js">// 适合于检查多重条件。
if (条件表达式1) {
    语句1；
} else if (条件表达式2)  {
    语句2；
} else if (条件表达式3)  {
   语句3；
 ....
} else {
    // 上述条件都不成立执行此处代码
}</code></pre>
</li>
</ul>
</li>
<li><p>执行逻辑</p>
<p><img src="http://helloxx.cn/d2img16.png" srcset="/myblog/img/loading.gif" alt=""></p>
</li>
</ul>
<h3 id="三元表达式"><a href="#三元表达式" class="headerlink" title="三元表达式"></a>三元表达式</h3><ul>
<li><p>语法结构</p>
<pre><code class="js">表达式1 ? 表达式2 : 表达式3;</code></pre>
</li>
<li><p>执行思路</p>
<ul>
<li>如果表达式1为 true ，则返回表达式2的值，如果表达式1为 false，则返回表达式3的值</li>
<li>简单理解： 就类似于  if  else （双分支） 的简写</li>
</ul>
</li>
</ul>
<h3 id="switch分支流程控制"><a href="#switch分支流程控制" class="headerlink" title="switch分支流程控制"></a>switch分支流程控制</h3><ul>
<li><p>语法结构</p>
<pre><code>switch 语句也是多分支语句，它用于基于不同的条件来执行不同的代码。当要针对变量设置一系列的特定值的选项时，就可以使用 switch。</code></pre><pre><code class="js">switch( 表达式 ){ 
    case value1:
        // 表达式 等于 value1 时要执行的代码
        break;
    case value2:
        // 表达式 等于 value2 时要执行的代码
        break;
    default:
        // 表达式 不等于任何一个 value 时要执行的代码
}</code></pre>
<ul>
<li><p>switch ：开关 转换  ， case ：小例子   选项</p>
</li>
<li><p>关键字 switch 后面括号内可以是表达式或值， 通常是一个变量</p>
</li>
<li><p>关键字 case , 后跟一个选项的表达式或值，后面跟一个冒号</p>
</li>
<li><p>switch 表达式的值会与结构中的 case 的值做比较 </p>
</li>
<li><p>如果存在匹配全等(===) ，则与该 case 关联的代码块会被执行，并在遇到 break 时停止，整个 switch 语句代码执行结束</p>
</li>
<li><p>如果所有的 case 的值都和表达式的值不匹配，则执行 default 里的代码</p>
<p><strong>注意： 执行case 里面的语句时，如果没有break，则继续执行下一个case里面的语句。</strong></p>
</li>
</ul>
</li>
<li><p>switch 语句和 if else if 语句的区别</p>
<ul>
<li>一般情况下，它们两个语句可以相互替换</li>
<li>switch…case 语句通常处理 case为比较确定值的情况， 而 if…else…语句更加灵活，常用于范围判断(大于、等于某个范围)</li>
<li>switch 语句进行条件判断后直接执行到程序的条件语句，效率更高。而if…else 语句有几种条件，就得判断多少次。</li>
<li>当分支比较少时，if… else语句的执行效率比 switch语句高。</li>
<li>当分支比较多时，switch语句的执行效率比较高，而且结构更清晰。 </li>
</ul>
</li>
</ul>
<h2 id="循环"><a href="#循环" class="headerlink" title="循环"></a>循环</h2><h3 id="for循环"><a href="#for循环" class="headerlink" title="for循环"></a>for循环</h3><ul>
<li><p>语法结构</p>
<pre><code class="js">for(初始化变量; 条件表达式; 操作表达式 ){
    //循环体
}</code></pre>
<table>
<thead>
<tr>
<th>名称</th>
<th>作用</th>
</tr>
</thead>
<tbody><tr>
<td>初始化变量</td>
<td>通常被用于初始化一个计数器，该表达式可以使用 var 关键字声明新的变量，这个变量帮我们来记录次数。</td>
</tr>
<tr>
<td>条件表达式</td>
<td>用于确定每一次循环是否能被执行。如果结果是 true 就继续循环，否则退出循环。</td>
</tr>
<tr>
<td>操作表达式</td>
<td>用于确定每一次循环是否能被执行。如果结果是 true 就继续循环，否则退出循环。</td>
</tr>
</tbody></table>
<p>执行过程：</p>
<ol>
<li>初始化变量，初始化操作在整个 for 循环只会执行一次。</li>
</ol>
</li>
<li><p>执行条件表达式，如果为true，则执行循环体语句，否则退出循环，循环结束。</p>
</li>
</ul>
<ol>
<li>执行操作表达式，此时第一轮结束。</li>
<li>第二轮开始，直接去执行条件表达式（不再初始化变量），如果为 true ，则去执行循环体语句，否则退出循环。</li>
<li>继续执行操作表达式，第二轮结束。</li>
<li>后续跟第二轮一致，直至条件表达式为假，结束整个 for 循环。</li>
</ol>
<p>断点调试：</p>
<pre><code>    断点调试是指自己在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。断点调试可以帮助观察程序的运行过程</code></pre><pre><code class="html">断点调试的流程：
1、浏览器中按 F12--&gt; sources --&gt;找到需要调试的文件--&gt;在程序的某一行设置断点
2、Watch: 监视，通过watch可以监视变量的值的变化，非常的常用。
3、摁下F11，程序单步执行，让程序一行一行的执行，这个时候，观察watch中变量的值的变化。</code></pre>
<ul>
<li><p>for 循环重复相同的代码</p>
<p>比如输出10句“媳妇我错了”</p>
<pre><code class="js">//  基本写法
for(var i = 1; i &lt;= 10; i++){
    console.log(&#39;媳妇我错了~&#39;);
}
// 用户输入次数
var num = prompt(&#39;请输入次数:&#39;)；
for ( var i = 1 ; i &lt;= num; i++) {
    console.log(&#39;媳妇我错了~&#39;);
} </code></pre>
</li>
<li><p>for 循环重复不相同的代码</p>
<p>例如，求输出1到100岁：</p>
<pre><code class="js">//  基本写法
for (var i = 1; i &lt;= 100; i++) {
      console.log(&#39;这个人今年&#39; + i + &#39;岁了&#39;);
}</code></pre>
<p>例如，求输出1到100岁，并提示出生、死亡</p>
<pre><code class="js">// for 里面是可以添加其他语句的 
for (var i = 1; i &lt;= 100; i++) {
 if (i == 1) {
    console.log(&#39;这个人今年1岁了， 它出生了&#39;);
 } else if (i == 100) {
    console.log(&#39;这个人今年100岁了，它死了&#39;);
  } else {
       console.log(&#39;这个人今年&#39; + i + &#39;岁了&#39;);
  }
}</code></pre>
<p>for循环因为有了计数器的存在，还可以重复的执行某些操作，比如做一些算术运算。</p>
</li>
</ul>
<h3 id="双重for循环"><a href="#双重for循环" class="headerlink" title="双重for循环"></a>双重for循环</h3><ul>
<li><p>双重 for 循环概述</p>
<pre><code>        循环嵌套是指在一个循环语句中再定义一个循环语句的语法结构，例如在for循环语句中，可以再嵌套一个for 循环，这样的 for 循环语句我们称之为双重for循环。</code></pre></li>
<li><p>双重 for 循环语法</p>
<pre><code class="js">for (外循环的初始; 外循环的条件; 外循环的操作表达式) {
    for (内循环的初始; 内循环的条件; 内循环的操作表达式) {  
       需执行的代码;
   }
}</code></pre>
<ul>
<li>内层循环可以看做外层循环的循环体语句</li>
<li>内层循环执行的顺序也要遵循 for 循环的执行顺序 </li>
<li>外层循环执行一次，内层循环要执行全部次数</li>
</ul>
</li>
<li><p>打印五行五列星星</p>
<pre><code class="js">var star = &#39;&#39;;
for (var j = 1; j &lt;= 3; j++) {
    for (var i = 1; i &lt;= 3; i++) {
      star += &#39;☆&#39;
    }
    // 每次满 5个星星 就 加一次换行
    star += &#39;\n&#39;
}
console.log(star);</code></pre>
<p>核心逻辑：</p>
<p>1.内层循环负责一行打印五个星星</p>
<p>2.外层循环负责打印五行</p>
</li>
<li><p>for 循环小结</p>
<ul>
<li>for 循环可以重复执行某些相同代码</li>
<li>for 循环可以重复执行些许不同的代码，因为我们有计数器</li>
<li>for 循环可以重复执行某些操作，比如算术运算符加法操作</li>
<li>随着需求增加，双重for循环可以做更多、更好看的效果</li>
<li>双重 for 循环，外层循环一次，内层 for 循环全部执行</li>
<li>for 循环是循环条件和数字直接相关的循环</li>
</ul>
</li>
</ul>
<h3 id="while循环"><a href="#while循环" class="headerlink" title="while循环"></a>while循环</h3><p>while语句的语法结构如下：</p>
<pre><code class="js">while (条件表达式) {
    // 循环体代码 
}</code></pre>
<p>执行思路：</p>
<ul>
<li>1 先执行条件表达式，如果结果为 true，则执行循环体代码；如果为 false，则退出循环，执行后面代码</li>
<li>2 执行循环体代码</li>
<li>3 循环体代码执行完毕后，程序会继续判断执行条件表达式，如条件仍为true，则会继续执行循环体，直到循环条件为 false 时，整个循环过程才会结束</li>
</ul>
<p>注意：</p>
<ul>
<li>使用 while 循环时一定要注意，它必须要有退出条件，否则会成为死循环</li>
</ul>
<h3 id="do-while循环"><a href="#do-while循环" class="headerlink" title="do-while循环"></a>do-while循环</h3><p>do… while 语句的语法结构如下：</p>
<pre><code class="js">do {
    // 循环体代码 - 条件表达式为 true 时重复执行循环体代码
} while(条件表达式);</code></pre>
<p>执行思路</p>
<ul>
<li><p>1 先执行一次循环体代码 </p>
</li>
<li><p>2 再执行条件表达式，如果结果为 true，则继续执行循环体代码，如果为 false，则退出循环，继续执行后面代码    </p>
<p>注意：先再执行循环体，再判断，do…while循环语句至少会执行一次循环体代码</p>
</li>
</ul>
<h3 id="continue、break"><a href="#continue、break" class="headerlink" title="continue、break"></a>continue、break</h3><p>continue 关键字用于立即跳出本次循环，继续下一次循环（本次循环体中 continue 之后的代码就会少执行一次）。</p>
<p>例如，吃5个包子，第3个有虫子，就扔掉第3个，继续吃第4个第5个包子，其代码实现如下：</p>
<pre><code class="js"> for (var i = 1; i &lt;= 5; i++) {
     if (i == 3) {
         console.log(&#39;这个包子有虫子，扔掉&#39;);
         continue; // 跳出本次循环，跳出的是第3次循环 
      }
      console.log(&#39;我正在吃第&#39; + i + &#39;个包子呢&#39;);
 }</code></pre>
<p>运行结果：</p>
<p><img src="http://helloxx.cn/d3img1.png" srcset="/myblog/img/loading.gif" alt=""></p>
<p>  break 关键字用于立即跳出整个循环（循环结束）。</p>
<p>  例如，吃5个包子，吃到第3个发现里面有半个虫子，其余的不吃了，其代码实现如下：</p>
<pre><code class="js">  for (var i = 1; i &lt;= 5; i++) {
     if (i == 3) {
         break; // 直接退出整个for 循环，跳到整个for下面的语句
     }
     console.log(&#39;我正在吃第&#39; + i + &#39;个包子呢&#39;);
   }</code></pre>
<p>  运行结果：</p>
<p>  <img src="http://helloxx.cn/d3img2.png" srcset="/myblog/img/loading.gif" alt=""></p>
<h2 id="代码规范"><a href="#代码规范" class="headerlink" title="代码规范"></a>代码规范</h2><h3 id="标识符命名规范"><a href="#标识符命名规范" class="headerlink" title="标识符命名规范"></a>标识符命名规范</h3><ul>
<li>变量、函数的命名必须要有意义</li>
<li>变量的名称一般用名词  </li>
<li>函数的名称一般用动词  </li>
</ul>
<h3 id="操作符规范"><a href="#操作符规范" class="headerlink" title="操作符规范"></a>操作符规范</h3><pre><code class="js">// 操作符的左右两侧各保留一个空格
for (var i = 1; i &lt;= 5; i++) {
   if (i == 3) {
       break; // 直接退出整个 for 循环，跳到整个for循环下面的语句
   }
   console.log(&#39;我正在吃第&#39; + i + &#39;个包子呢&#39;);
}</code></pre>
<h3 id="单行注释规范"><a href="#单行注释规范" class="headerlink" title="单行注释规范"></a>单行注释规范</h3><pre><code class="js">for (var i = 1; i &lt;= 5; i++) {
   if (i == 3) {
       break; // 单行注释前面注意有个空格
   }
   console.log(&#39;我正在吃第&#39; + i + &#39;个包子呢&#39;);
}</code></pre>
<h3 id="其他规范"><a href="#其他规范" class="headerlink" title="其他规范"></a>其他规范</h3><pre><code>关键词、操作符之间后加空格</code></pre><p><img src="http://helloxx.cn/d3img3.png" srcset="/myblog/img/loading.gif" alt=""></p>
<h2 id="数组"><a href="#数组" class="headerlink" title="数组"></a>数组</h2><h3 id="数组的概念"><a href="#数组的概念" class="headerlink" title="数组的概念"></a>数组的概念</h3><ul>
<li>数组可以把一组相关的数据一起存放，并提供方便的访问(获取）方式。</li>
<li>数组是指<strong>一组数据的集合</strong>，其中的每个数据被称作<strong>元素</strong>，在数组中可以<strong>存放任意类型的元素</strong>。数组是一种将一组数据存储在单个变量名下的优雅方式。</li>
</ul>
<h3 id="创建数组"><a href="#创建数组" class="headerlink" title="创建数组"></a>创建数组</h3><p>JS 中创建数组有两种方式：</p>
<ul>
<li><p>利用  new 创建数组  </p>
<pre><code class="js">var 数组名 = new Array() ；
var arr = new Array();   // 创建一个新的空数组</code></pre>
<p>注意 Array () ，A 要大写    </p>
</li>
<li><p>利用数组字面量创建数组</p>
<pre><code class="js">//1. 使用数组字面量方式创建空的数组
var  数组名 = []；
//2. 使用数组字面量方式创建带初始值的数组
var  数组名 = [&#39;小白&#39;,&#39;小黑&#39;,&#39;大黄&#39;,&#39;瑞奇&#39;];</code></pre>
<ul>
<li>数组的字面量是方括号 [ ] </li>
<li>声明数组并赋值称为数组的初始化</li>
<li>这种字面量方式也是我们以后最多使用的方式</li>
</ul>
</li>
<li><p>数组元素的类型</p>
<p>数组中可以存放任意类型的数据，例如字符串，数字，布尔值等。</p>
<pre><code class="js">var arrStus = [&#39;小白&#39;,12,true,28.9];</code></pre>
</li>
</ul>
<h3 id="获取数组中的元素"><a href="#获取数组中的元素" class="headerlink" title="获取数组中的元素"></a>获取数组中的元素</h3><p>​        索引 (下标) ：用来访问数组元素的序号（数组下标从 0 开始）。</p>
<p><img src="http://helloxx.cn/d4img1.png" srcset="/myblog/img/loading.gif" alt=""></p>
<p>​        数组可以通过索引来访问、设置、修改对应的数组元素，可以通过“数组名[索引]”的形式来获取数组中的元素。</p>
<pre><code class="js">// 定义数组
var arrStus = [1,2,3];
// 获取数组中的第2个元素
alert(arrStus[1]);    </code></pre>
<p>注意：如果访问时数组没有和索引值对应的元素，则得到的值是undefined</p>
<h3 id="遍历数组"><a href="#遍历数组" class="headerlink" title="遍历数组"></a>遍历数组</h3><ul>
<li><p>数组遍历</p>
<p>  ​        把数组中的每个元素从头到尾都访问一次（类似学生的点名），可以通过 for 循环索引遍历数组中的每一项</p>
</li>
</ul>
<pre><code class="js">var arr = [&#39;red&#39;,&#39;green&#39;, &#39;blue&#39;];
for(var i = 0; i &lt; arr.length; i++){
    console.log(arrStus[i]);
}</code></pre>
<ul>
<li><p>数组的长度</p>
<p>数组的长度：默认情况下表示数组中元素的个数</p>
<p>使用“数组名.length”可以访问数组元素的数量（数组长度）。</p>
<pre><code class="js">var arrStus = [1,2,3];
alert(arrStus.length);  // 3</code></pre>
<p>  <strong>注意</strong>：</p>
<ul>
<li>此处数组的长度是数组元素的个数 ，不要和数组的索引号混淆。</li>
</ul>
</li>
<li><p>当我们数组里面的元素个数发生了变化，这个 length 属性跟着一起变化</p>
<ul>
<li>数组的length属性可以被修改：</li>
</ul>
</li>
<li><p>如果设置的length属性值大于数组的元素个数，则会在数组末尾出现空白元素；</p>
<ul>
<li>如果设置的length属性值小于数组的元素个数，则会把超过该值的数组元素删除</li>
</ul>
</li>
</ul>
<h3 id="数组中新增元素"><a href="#数组中新增元素" class="headerlink" title="数组中新增元素"></a>数组中新增元素</h3><p>​        数组中可以通过以下方式在数组的末尾插入新元素：</p>
<pre><code class="js">  数组[ 数组.length ] = 新数据;</code></pre>
<h2 id="函数"><a href="#函数" class="headerlink" title="函数"></a>函数</h2><h3 id="函数的概念"><a href="#函数的概念" class="headerlink" title="函数的概念"></a>函数的概念</h3><p>​        在 JS 里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。虽然 for循环语句也能实现一些简单的重复操作，但是比较具有局限性，此时我们就可以使用 JS 中的函数。</p>
<p>​        函数：就是<strong>封装了一段可被重复调用执行的代码块</strong>。通过此代码块可以<strong>实现大量代码的重复使用</strong>。  </p>
<h3 id="函数的使用"><a href="#函数的使用" class="headerlink" title="函数的使用"></a>函数的使用</h3><h4 id="声明函数"><a href="#声明函数" class="headerlink" title="声明函数"></a>声明函数</h4><pre><code class="js">// 声明函数
function 函数名() {
    //函数体代码
}</code></pre>
<ul>
<li><p>function 是声明函数的关键字,必须小写</p>
</li>
<li><p>由于函数一般是为了实现某个功能才定义的， 所以通常我们将函数名命名为动词，比如 getSum</p>
</li>
</ul>
<h4 id="调用函数"><a href="#调用函数" class="headerlink" title="调用函数"></a>调用函数</h4><pre><code class="js">// 调用函数
函数名();  // 通过调用函数名来执行函数体代码</code></pre>
<ul>
<li><p>调用的时候千万不要忘记添加小括号</p>
</li>
<li><p>口诀：函数不调用，自己不执行</p>
<p>注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码。</p>
</li>
</ul>
<h4 id="函数的封装"><a href="#函数的封装" class="headerlink" title="函数的封装"></a>函数的封装</h4><ul>
<li><p>函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口</p>
</li>
<li><p>简单理解：封装类似于将电脑配件整合组装到机箱中 ( 类似快递打包）  </p>
<p>例子：封装计算1-100累加和</p>
<pre><code class="js">//计算1-100之间值的函数
// 声明函数
function getSum(){
  var sumNum = 0;// 准备一个变量，保存数字和
  for (var i = 1; i &lt;= 100; i++) {
    sumNum += i;// 把每个数值 都累加 到变量中
  }
  alert(sumNum);
}
// 调用函数
getSum();</code></pre>
</li>
</ul>
<h3 id="函数的参数"><a href="#函数的参数" class="headerlink" title="函数的参数"></a>函数的参数</h3><h4 id="函数参数语法"><a href="#函数参数语法" class="headerlink" title="函数参数语法"></a>函数参数语法</h4><ul>
<li><p>形参：函数定义时设置接收调用时传入</p>
</li>
<li><p>实参：函数调用时传入小括号内的真实数据</p>
<p>​    参数的作用 : 在函数内部某些值不能固定，我们可以通过参数在调用函数时传递不同的值进去。</p>
<p>函数参数的运用：</p>
<pre><code class="js">// 带参数的函数声明
function 函数名(形参1, 形参2 , 形参3...) { // 可以定义任意多的参数，用逗号分隔
  // 函数体
}
// 带参数的函数调用
函数名(实参1, 实参2, 实参3...); </code></pre>
<ol>
<li>调用的时候实参值是传递给形参的</li>
</ol>
</li>
</ul>
<ol start="2">
<li>形参简单理解为：不用声明的变量<ol start="3">
<li>实参和形参的多个参数之间用逗号（,）分隔</li>
</ol>
</li>
</ol>
<h4 id="函数形参和实参数量不匹配时"><a href="#函数形参和实参数量不匹配时" class="headerlink" title="函数形参和实参数量不匹配时"></a>函数形参和实参数量不匹配时</h4><table>
<thead>
<tr>
<th>参数个数</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>实参个数等于形参个数</td>
<td>输出正确结果</td>
</tr>
<tr>
<td>实参个数多于形参个数</td>
<td>只取到形参的个数</td>
</tr>
<tr>
<td>实参个数小于形参个数</td>
<td>多的形参定义为undefined，结果为NaN</td>
</tr>
</tbody></table>
<pre><code>注意：在JavaScript中，形参的默认值是undefined。</code></pre><p>小结：</p>
<ul>
<li>函数可以带参数也可以不带参数</li>
<li>声明函数的时候，函数名括号里面的是形参，形参的默认值为 undefined</li>
<li>调用函数的时候，函数名括号里面的是实参</li>
<li>多个参数中间用逗号分隔</li>
<li>形参的个数可以和实参个数不匹配，但是结果不可预计，我们尽量要匹配</li>
</ul>
<h3 id="函数的返回值"><a href="#函数的返回值" class="headerlink" title="函数的返回值"></a>函数的返回值</h3><h4 id="return-语句"><a href="#return-语句" class="headerlink" title="return 语句"></a>return 语句</h4><pre><code>返回值：函数调用整体代表的数据；函数执行完成后可以通过return语句将指定数据返回 。</code></pre><pre><code class="js">// 声明函数
function 函数名（）{
    ...
    return  需要返回的值；
}
// 调用函数
函数名();    // 此时调用函数就可以得到函数体内return 后面的值</code></pre>
<ul>
<li>在使用 return 语句时，函数会停止执行，并返回指定的值</li>
<li>如果函数没有 return ，返回的值是 undefined</li>
</ul>
<h4 id="break-continue-return-的区别"><a href="#break-continue-return-的区别" class="headerlink" title="break ,continue ,return 的区别"></a>break ,continue ,return 的区别</h4><ul>
<li>break ：结束当前的循环体（如 for、while）</li>
<li>continue ：跳出本次循环，继续执行下次循环（如 for、while）</li>
<li>return ：不仅可以退出循环，还能够返回 return 语句中的值，同时还可以结束当前的函数体内的代码</li>
</ul>
<h3 id="arguments的使用"><a href="#arguments的使用" class="headerlink" title="arguments的使用"></a>arguments的使用</h3><p>​        当不确定有多少个参数传递的时候，可以用 arguments 来获取。JavaScript 中，arguments实际上它是当前函数的一个内置对象。所有函数都内置了一个 arguments 对象，arguments 对象中存储了传递的所有实参。arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：</p>
<ul>
<li><p>具有 length 属性</p>
</li>
<li><p>按索引方式储存数据</p>
</li>
<li><p>不具有数组的 push , pop 等方法</p>
<p>注意：在函数内部使用该对象，用此对象获取函数调用时传的实参。</p>
</li>
</ul>
<pre><code class="js">// 求最大值
function getMax(){
    var max = arguments[0]
    for (var i = 1; i&lt; arguments.length; i++) {
        if (arguments[i] &gt; max){
            max = arguments[i]
        }
    }
    return max
}
console.log(getMax(1,2,3))
console.log(getMax(11,22,333,4123,12341,123,123,1))</code></pre>
<h3 id="函数案例"><a href="#函数案例" class="headerlink" title="函数案例"></a>函数案例</h3><pre><code>    函数内部可以调用另一个函数，在同一作用域代码中，函数名即代表封装的操作，使用函数名加括号即可以将封装的操作执行。</code></pre><h3 id="函数的两种声明方式"><a href="#函数的两种声明方式" class="headerlink" title="函数的两种声明方式"></a>函数的两种声明方式</h3><ul>
<li><p>自定义函数方式(命名函数)</p>
<p>利用函数关键字 function 自定义函数方式</p>
<pre><code class="js">// 声明定义方式
function fn() {...}
// 调用  
fn();  </code></pre>
<ul>
<li>因为有名字，所以也被称为命名函数</li>
<li>调用函数的代码既可以放到声明函数的前面，也可以放在声明函数的后面</li>
</ul>
</li>
<li><p>函数表达式方式(匿名函数）</p>
<p>利用函数表达式方式的写法如下： </p>
<pre><code class="js">// 这是函数表达式写法，匿名函数后面跟分号结束
var fn = function(){...}；
// 调用的方式，函数调用必须写到函数体下面
fn();</code></pre>
<ul>
<li>因为函数没有名字，所以也被称为匿名函数</li>
<li>这个fn 里面存储的是一个函数  </li>
<li>函数表达式方式原理跟声明变量方式是一致的</li>
<li>函数调用的代码必须写到函数体后面</li>
</ul>
</li>
</ul>
<h2 id="作用域"><a href="#作用域" class="headerlink" title="作用域"></a>作用域</h2><h3 id="作用域概述"><a href="#作用域概述" class="headerlink" title="作用域概述"></a>作用域概述</h3><pre><code>通常来说，一段程序代码中所用到的名字并不总是有效和可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。作用域的使用提高了程序逻辑的局部性，增强了程序的可靠性，减少了名字冲突。

JavaScript（es6前）中的作用域有两种：</code></pre><ul>
<li>全局作用域</li>
<li>局部作用域（函数作用域）    </li>
</ul>
<h3 id="全局作用域"><a href="#全局作用域" class="headerlink" title="全局作用域"></a>全局作用域</h3><pre><code>作用于所有代码执行的环境(整个 script 标签内部)或者一个独立的 js 文件。</code></pre><h3 id="局部作用域"><a href="#局部作用域" class="headerlink" title="局部作用域"></a>局部作用域</h3><pre><code>作用于函数内的代码环境，就是局部作用域。 因为跟函数有关系，所以也称为函数作用域。</code></pre><h3 id="JS没有块级作用域"><a href="#JS没有块级作用域" class="headerlink" title="JS没有块级作用域"></a>JS没有块级作用域</h3><ul>
<li><p>块作用域由 { } 包括。</p>
</li>
<li><p>在其他编程语言中（如 java、c#等），在 if 语句、循环语句中创建的变量，仅仅只能在本 if 语句、本循环语句中使用，如下面的Java代码：    </p>
<p>java有块级作用域：</p>
<pre><code class="java">if(true){
  int num = 123;
  system.out.print(num);  // 123
}
system.out.print(num);    // 报错</code></pre>
<p>以上java代码会报错，是因为代码中 { } 即一块作用域，其中声明的变量 num，在 “{ }” 之外不能使用；</p>
<p>而与之类似的JavaScript代码，则不会报错：</p>
<p>Js中没有块级作用域（在ES6之前）</p>
<pre><code class="js">if(true){
  var num = 123;
  console.log(123); //123
}
console.log(123);   //123</code></pre>
</li>
</ul>
<h2 id="变量的作用域"><a href="#变量的作用域" class="headerlink" title="变量的作用域"></a>变量的作用域</h2><pre><code>在JavaScript中，根据作用域的不同，变量可以分为两种：</code></pre><ul>
<li>全局变量</li>
<li>局部变量</li>
</ul>
<p>全局变量</p>
<pre><code>在全局作用域下声明的变量叫做全局变量（在函数外部定义的变量）。</code></pre><ul>
<li>全局变量在代码的任何位置都可以使用</li>
<li>在全局作用域下 var 声明的变量 是全局变量</li>
<li>特殊情况下，在函数内不使用 var 声明的变量也是全局变量（不建议使用）</li>
</ul>
<p>局部变量</p>
<pre><code>在局部作用域下声明的变量叫做局部变量（在函数内部定义的变量）</code></pre><ul>
<li>局部变量只能在该函数内部使用</li>
<li>在函数内部 var 声明的变量是局部变量</li>
<li>函数的形参实际上就是局部变量</li>
</ul>
<p>全局变量和局部变量的区别</p>
<ul>
<li>全局变量：在任何一个地方都可以使用，只有在浏览器关闭时才会被销毁，因此比较占内存</li>
<li>局部变量：只在函数内部使用，当其所在的代码块被执行时，会被初始化；当代码块运行结束后，就会被销毁，因此更节省内存空间</li>
</ul>
<h2 id="作用域链"><a href="#作用域链" class="headerlink" title="作用域链"></a>作用域链</h2><pre><code>只要是代码都一个作用域中，写在函数内部的局部作用域，未写在任何函数内部即在全局作用域中；如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域；根据在**[内部函数可以访问外部函数变量]**的这种机制，用链式查找决定哪些数据能被内部函数访问，就称作作用域链

案例分析1：</code></pre><pre><code class="js">function f1() {
    var num = 123;
    function f2() {
        console.log( num );
    }
    f2();
}
var num = 456;
f1();</code></pre>
<p><img src="http://helloxx.cn/d5img1.png" srcset="/myblog/img/loading.gif" alt=""></p>
<pre><code>作用域链：采取就近原则的方式来查找变量最终的值。</code></pre><pre><code class="js">var a = 1;
function fn1() {
    var a = 2;
    var b = &#39;22&#39;;
    fn2();
    function fn2() {
        var a = 3;
        fn3();
        function fn3() {
            var a = 4;
            console.log(a); //a的值 ?
            console.log(b); //b的值 ?
        }
    }
}
fn1();</code></pre>
<p><img src="http://helloxx.cn/d5img2.png" srcset="/myblog/img/loading.gif" alt=""></p>
<h2 id="预解析"><a href="#预解析" class="headerlink" title="预解析"></a>预解析</h2><p>4.1 预解析的相关概念</p>
<pre><code>JavaScript 代码是由浏览器中的 JavaScript 解析器来执行的。JavaScript 解析器在运行 JavaScript 代码的时候分为两步：预解析和代码执行。</code></pre><ul>
<li><p>预解析：在当前作用域下, JS 代码执行之前，浏览器会默认把带有 var 和 function 声明的变量在内存中进行提前声明或者定义。</p>
</li>
<li><p>代码执行： 从上到下执行JS语句。</p>
<p><strong>预解析会把变量和函数的声明在代码执行之前执行完成。</strong></p>
</li>
</ul>
<p>4.2 变量预解析</p>
<pre><code>预解析也叫做变量、函数提升。
变量提升（变量预解析）： 变量的声明会被提升到当前作用域的最上面，变量的赋值不会提升。</code></pre><pre><code class="js">console.log(num);  // 结果是多少？
var num = 10;      // ？</code></pre>
<pre><code>结果：undefined

注意：**变量提升只提升声明，不提升赋值**</code></pre><p>4.3 函数预解析</p>
<pre><code>函数提升： 函数的声明会被提升到当前作用域的最上面，但是不会调用函数。</code></pre><pre><code class="js">fn();
function fn() {
    console.log(&#39;打印&#39;);
}</code></pre>
<pre><code>结果：控制台打印字符串 --- ”打印“ 

注意：函数声明代表函数整体，所以函数提升后，函数名代表整个函数，但是函数并没有被调用！    </code></pre><p>4.4 函数表达式声明函数问题</p>
<pre><code>函数表达式创建函数，会执行变量提升，此时接收函数的变量名无法正确的调用：</code></pre><pre><code class="js">fn();
var  fn = function() {
    console.log(&#39;想不到吧&#39;);
}</code></pre>
<pre><code>结果：报错提示 ”fn is not a function&quot;

解释：该段代码执行之前，会做变量声明提升，fn在提升之后的值是undefined；而fn调用是在fn被赋值为函数体之前，此时fn的值是undefined，所以无法正确调用</code></pre><h2 id="对象"><a href="#对象" class="headerlink" title="对象"></a>对象</h2><h3 id="对象的相关概念"><a href="#对象的相关概念" class="headerlink" title="对象的相关概念"></a>对象的相关概念</h3><ul>
<li><p>什么是对象？</p>
<pre><code>在 JavaScript 中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如字符串、数值、数组、函数等。
  对象是由属性和方法组成的。</code></pre><ul>
<li><p>属性：事物的特征，在对象中用属性来表示（常用名词）</p>
</li>
<li><p>方法：事物的行为，在对象中用方法来表示（常用动词）</p>
<p><img src="http://helloxx.cn/d5img3.png" srcset="/myblog/img/loading.gif" alt=""></p>
</li>
</ul>
</li>
<li><p>为什么需要对象？</p>
<pre><code>保存一个值时，可以使用变量，保存多个值（一组值）时，可以使用数组。

  如果要保存一个人的完整信息呢？

  例如，将“张三疯”的个人的信息保存在数组中的方式为：</code></pre><pre><code>var arr = [‘张三疯’, ‘男&#39;, 128,154];</code></pre><pre><code>上述例子中用数组保存数据的缺点是：数据只能通过索引值访问，开发者需要清晰的清除所有的数据的排行才能准确地获取数据，而当数据量庞大时，不可能做到记忆所有数据的索引值。

为了让更好地存储一组数据，对象应运而生：对象中为每项数据设置了属性名称，可以访问数据更语义化，数据结构清晰，表意明显，方便开发者使用。

使用对象记录上组数据为：</code></pre><pre><code class="js">var obj = {
    &quot;name&quot;:&quot;张三疯&quot;,
    &quot;sex&quot;:&quot;男&quot;,
    &quot;age&quot;:128,
    &quot;height&quot;:154
}</code></pre>
<pre><code>JS中的对象表达结构更清晰，更强大。</code></pre></li>
</ul>
<h3 id="创建对象的三种方式"><a href="#创建对象的三种方式" class="headerlink" title="创建对象的三种方式"></a>创建对象的三种方式</h3><ul>
<li><p>利用字面量创建对象 </p>
<h5 id="使用对象字面量创建对象："><a href="#使用对象字面量创建对象：" class="headerlink" title="使用对象字面量创建对象："></a><strong>使用对象字面量创建对象</strong>：</h5><pre><code>    就是花括号 { } 里面包含了表达这个具体事物（对象）的属性和方法；{ } 里面采取键值对的形式表示 </code></pre><ul>
<li><p>键：相当于属性名</p>
</li>
<li><p>值：相当于属性值，可以是任意类型的值（数字类型、字符串类型、布尔类型，函数类型等）</p>
<p>代码如下：</p>
<pre><code class="js">var star = {
    name : &#39;pink&#39;,
    age : 18,
    sex : &#39;男&#39;,
    sayHi : function(){
        alert(&#39;大家好啊~&#39;);
    }
};</code></pre>
<p>上述代码中 star即是创建的对象。</p>
</li>
</ul>
</li>
<li><p>对象的使用</p>
<ul>
<li><p>对象的属性</p>
<ul>
<li>对象中存储<strong>具体数据</strong>的 “键值对”中的 “键”称为对象的属性，即对象中存储具体数据的项</li>
</ul>
</li>
<li><p>对象的方法</p>
<ul>
<li>对象中存储<strong>函数</strong>的 “键值对”中的 “键”称为对象的方法，即对象中存储函数的项</li>
</ul>
</li>
<li><p>访问对象的属性</p>
<ul>
<li><p>对象里面的属性调用 : 对象.属性名 ，这个小点 . 就理解为“ 的 ”  </p>
</li>
<li><p>对象里面属性的另一种调用方式 : 对象[‘属性名’]，注意方括号里面的属性必须加引号      </p>
<p>示例代码如下：</p>
<pre><code class="js">console.log(star.name)     // 调用名字属性
console.log(star[&#39;name&#39;])  // 调用名字属性</code></pre>
</li>
</ul>
</li>
<li><p>调用对象的方法</p>
<ul>
<li><p>对象里面的方法调用：对象.方法名() ，注意这个方法名字后面一定加括号 </p>
<p>示例代码如下：</p>
<pre><code class="js">star.sayHi();              // 调用 sayHi 方法,注意，一定不要忘记带后面的括号</code></pre>
</li>
</ul>
</li>
<li><p>变量、属性、函数、方法总结</p>
<pre><code>属性是对象的一部分，而变量不是对象的一部分，变量是单独存储数据的容器</code></pre><ul>
<li>变量：单独声明赋值，单独存在</li>
<li>属性：对象里面的变量称为属性，不需要声明，用来描述该对象的特征</li>
</ul>
</li>
</ul>
</li>
</ul>
<pre><code>    方法是对象的一部分，函数不是对象的一部分，函数是单独封装操作的容器

- 函数：单独存在的，通过“函数名()”的方式就可以调用
- 方法：对象里面的函数称为方法，方法不需要声明，使用“对象.方法名()”的方式就可以调用，方法用来描述该对象的行为和功能。 </code></pre><ul>
<li><p>利用 new Object 创建对象 </p>
<ul>
<li><p>创建空对象</p>
<pre><code class="js">var andy = new Obect();</code></pre>
<p>通过内置构造函数Object创建对象，此时andy变量已经保存了创建出来的空对象</p>
</li>
<li><p>给空对象添加属性和方法</p>
<ul>
<li><p>通过对象操作属性和方法的方式，来为对象增加属性和方法</p>
<p>示例代码如下：</p>
</li>
</ul>
<pre><code class="js">andy.name = &#39;pink&#39;;
andy.age = 18;
andy.sex = &#39;男&#39;;
andy.sayHi = function(){
    alert(&#39;大家好啊~&#39;);
}</code></pre>
<p>注意：</p>
<ul>
<li>Object() ：第一个字母大写   </li>
<li>new Object() ：需要 new 关键字</li>
<li>使用的格式：对象.属性 =  值;     </li>
</ul>
</li>
</ul>
</li>
<li><p>利用构造函数创建对象</p>
<ul>
<li><p>构造函数</p>
<ul>
<li><p>构造函数：是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总与 new 运算符一起使用。我们可以把对象中一些公共的属性和方法抽取出来，然后封装到这个函数里面。</p>
</li>
<li><p>构造函数的封装格式：</p>
<pre><code class="js">function 构造函数名(形参1,形参2,形参3) {
     this.属性名1 = 参数1;
     this.属性名2 = 参数2;
     this.属性名3 = 参数3;
     this.方法名 = 函数体;
}</code></pre>
</li>
<li><p>构造函数的调用格式</p>
<pre><code>var obj = new 构造函数名(实参1，实参2，实参3)</code></pre><p>以上代码中，obj即接收到构造函数创建出来的对象。</p>
</li>
<li><p>注意事项</p>
<ol>
<li>构造函数约定<strong>首字母大写</strong>。</li>
<li>函数内的属性和方法前面需要添加 <strong>this</strong> ，表示当前对象的属性和方法。</li>
<li>构造函数中<strong>不需要 return 返回结果</strong>。</li>
<li>当我们创建对象的时候，<strong>必须用 new 来调用构造函数</strong>。</li>
</ol>
</li>
<li><p>其他</p>
<p> 构造函数，如 Stars()，抽象了对象的公共部分，封装到了函数里面，它泛指某一大类（class）<br> 创建对象，如 new Stars()，特指某一个，通过 new 关键字创建对象的过程我们也称为对象实例化</p>
</li>
</ul>
</li>
</ul>
</li>
<li><p>new关键字的作用</p>
<ol>
<li>在构造函数代码开始执行之前，创建一个空对象；</li>
<li>修改this的指向，把this指向创建出来的空对象；</li>
<li>执行函数的代码</li>
<li>在函数完成之后，返回this—即创建出来的对象</li>
</ol>
<h3 id="5-3-遍历对象"><a href="#5-3-遍历对象" class="headerlink" title="5.3 遍历对象"></a>5.3 遍历对象</h3><pre><code>for...in 语句用于对数组或者对象的属性进行循环操作。

其语法如下：</code></pre><pre><code class="js">for (变量 in 对象名字) {
    // 在此执行代码
}</code></pre>
<pre><code>语法中的变量是自定义的，它需要符合命名规范，通常我们会将这个变量写为 k 或者 key。</code></pre><pre><code class="js">for (var k in obj) {
    console.log(k);      // 这里的 k 是属性名
    console.log(obj[k]); // 这里的 obj[k] 是属性值
}</code></pre>
</li>
</ul>
<h2 id="内置对象"><a href="#内置对象" class="headerlink" title="内置对象"></a>内置对象</h2><h3 id="内置对象-1"><a href="#内置对象-1" class="headerlink" title="内置对象"></a>内置对象</h3><p>​         JavaScript 中的对象分为3种：<strong>自定义对象 、内置对象、 浏览器对象</strong><br>​        前面两种对象是JS 基础 内容，属于 ECMAScript；  第三个浏览器对象属于 JS 独有的， JS API 讲解内置对象就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是<strong>最基本而必要的功能</strong>（属性和方法），内置对象最大的优点就是帮助我们快速开发</p>
<p>​         JavaScript 提供了多个内置对象：Math、 Date 、Array、String等    </p>
<h3 id="查文档"><a href="#查文档" class="headerlink" title="查文档"></a>查文档</h3><p>​        查找文档：学习一个内置对象的使用，只要学会其常用成员的使用即可，我们可以通过查文档学习，可以通过MDN/W3C来查询。<br>​        Mozilla 开发者网络（MDN）提供了有关开放网络技术（Open Web）的信息，包括 HTML、CSS 和万维网及 HTML5 应用的 API。<br>​        MDN:<a href="https://developer.mozilla.org/zh-CN/" target="_blank" rel="noopener">https://developer.mozilla.org/zh-CN/</a></p>
<h3 id="Math对象"><a href="#Math对象" class="headerlink" title="Math对象"></a>Math对象</h3><p>​        Math 对象不是构造函数，它具有数学常数和函数的属性和方法。跟数学相关的运算（求绝对值，取整、最大值等）可以使用 Math 中的成员。</p>
<table>
<thead>
<tr>
<th>属性、方法名</th>
<th>功能</th>
</tr>
</thead>
<tbody><tr>
<td>Math.PI</td>
<td>圆周率</td>
</tr>
<tr>
<td>Math.floor()</td>
<td>向下取整</td>
</tr>
<tr>
<td>Math.ceil()</td>
<td>向上取整</td>
</tr>
<tr>
<td>Math.round()</td>
<td>四舍五入版 就近取整   注意负数 比如 -3.5   结果是  -3</td>
</tr>
<tr>
<td>Math.abs()</td>
<td>绝对值</td>
</tr>
<tr>
<td>Math.max()/Math.min()</td>
<td>求最大和最小值</td>
</tr>
<tr>
<td>Math.random()</td>
<td>获取范围在[0,1]内的随机值</td>
</tr>
</tbody></table>
<p>​    注意：上面的方法使用时必须带括号</p>
<p>​    <strong>获取指定范围内的随机整数</strong>：</p>
<pre><code class="js">function getRandom(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min; 
}</code></pre>
<h3 id="日期对象"><a href="#日期对象" class="headerlink" title="日期对象"></a>日期对象</h3><p>​         Date 对象和 Math 对象不一样，Date是一个构造函数，所以使用时需要实例化后才能使用其中具体方法和属性。Date 实例用来处理日期和时间</p>
<ul>
<li><p>使用Date实例化日期对象</p>
<ul>
<li>获取当前时间必须实例化：</li>
</ul>
<pre><code class="js">var now = new Date();</code></pre>
<ul>
<li>获取指定时间的日期对象</li>
</ul>
<pre><code class="js">var future = new Date(&#39;2019/5/1&#39;);</code></pre>
<p>注意：如果创建实例时并未传入参数，则得到的日期对象是当前时间对应的日期对象</p>
</li>
<li><p>使用Date实例的方法和属性</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>代码</th>
</tr>
</thead>
<tbody><tr>
<td>getFullyear()</td>
<td>获取当年</td>
<td>dobj.getFullYear()</td>
</tr>
<tr>
<td>getMonth()</td>
<td>获取当月(0-11)</td>
<td>dobj-getMonth()</td>
</tr>
<tr>
<td>getDate()</td>
<td>获取当天日期</td>
<td>dobj.getDate()</td>
</tr>
<tr>
<td>getDay()</td>
<td>获取星期几(周日0到周六6)</td>
<td>dobj.getDay()</td>
</tr>
<tr>
<td>getHours()</td>
<td>获取当前小时</td>
<td>dobj.getHours()</td>
</tr>
<tr>
<td>getMinutes()</td>
<td>获取当前分钟</td>
<td>dobj.getMinutes()</td>
</tr>
<tr>
<td>getSeconds()</td>
<td>获取当前秒钟</td>
<td>dobj.getSeconds()</td>
</tr>
</tbody></table>
</li>
</ul>
<ul>
<li><p>通过Date实例获取总毫米数</p>
<ul>
<li><p>总毫秒数的含义</p>
<p>​    基于1970年1月1日（世界标准时间）起的毫秒数</p>
</li>
<li><p>获取总毫秒数</p>
<pre><code class="js">// 实例化Date对象
var now = new Date();
// 1. 用于获取对象的原始值
console.log(date.valueOf())    
console.log(date.getTime())    
// 2. 简单写可以这么做
var now = + new Date();            
// 3. HTML5中提供的方法，有兼容性问题
var now = Date.now();</code></pre>
</li>
</ul>
</li>
</ul>
<h3 id="数组对象"><a href="#数组对象" class="headerlink" title="数组对象"></a>数组对象</h3><h4 id="创建数组的两种方式"><a href="#创建数组的两种方式" class="headerlink" title="创建数组的两种方式"></a>创建数组的两种方式</h4><ul>
<li><p>字面量方式</p>
<ul>
<li><p>示例代码如下：</p>
<pre><code class="js">var arr = [1,&quot;test&quot;,true];</code></pre>
</li>
</ul>
</li>
<li><p>new Array()</p>
<ul>
<li><p>示例代码如下：</p>
<pre><code>var arr = new Array();</code></pre><p>​    注意：上面代码中arr创建出的是一个空数组，如果需要使用构造函数Array创建非空数组，可以在创建数组时传入参数</p>
<p>​    参数传递规则如下：</p>
<ul>
<li><p>如果只传入一个参数，则参数规定了数组的长度</p>
</li>
<li><p>如果传入了多个参数，则参数称为数组的元素</p>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="检测是否为数组"><a href="#检测是否为数组" class="headerlink" title="检测是否为数组"></a>检测是否为数组</h4><ul>
<li><p>instanceof 运算符</p>
<ul>
<li><p>instanceof 可以判断一个对象是否是某个构造函数的实例</p>
<pre><code class="js">var arr = [1, 23];
var obj = {};
console.log(arr instanceof Array); // true
console.log(obj instanceof Array); // false</code></pre>
</li>
</ul>
</li>
<li><p>Array.isArray()</p>
<ul>
<li><p>Array.isArray()用于判断一个对象是否为数组，isArray() 是 HTML5 中提供的方法</p>
<pre><code class="js">var arr = [1, 23];
var obj = {};
console.log(Array.isArray(arr));   // true
console.log(Array.isArray(obj));   // false</code></pre>
</li>
</ul>
</li>
</ul>
<h4 id="添加删除数组元素的方法"><a href="#添加删除数组元素的方法" class="headerlink" title="添加删除数组元素的方法"></a>添加删除数组元素的方法</h4><ul>
<li><p>数组中有进行增加、删除元素的方法，部分方法如下表</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>返回值</th>
</tr>
</thead>
<tbody><tr>
<td>push(参数 1….)</td>
<td>末尾添加一个或多个元素，注意修改原数组</td>
<td>并返回新的长度</td>
</tr>
<tr>
<td>pop()</td>
<td>删除数组最后一个元素，把数组长度减1, 无参数、修改原数 组</td>
<td>返回它删除的元素的值</td>
</tr>
<tr>
<td>unshift(参数1…)</td>
<td>向数组的开头添加一个或更多元素，注意修改原数组</td>
<td>并返回新的长度</td>
</tr>
<tr>
<td>shift()</td>
<td>删除数组的第一个元素，数组长度减1无参数、修改原数组</td>
<td>并返回第一个元素的值</td>
</tr>
</tbody></table>
<p>注意：push、unshift为增加元素方法；pop、shift为删除元素的方法</p>
</li>
</ul>
<h4 id="数组排序"><a href="#数组排序" class="headerlink" title="数组排序"></a>数组排序</h4><ul>
<li><p>数组中有对数组本身排序的方法，部分方法如下表</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>是否修改原数组</th>
</tr>
</thead>
<tbody><tr>
<td>reverse()</td>
<td>颠倒数组中元素的顺序,无参数</td>
<td>该方法会改变原来的数组，返回新数组</td>
</tr>
<tr>
<td>sort()</td>
<td>对数组的元素进行排序</td>
<td>该方法会改变原来的数组，返回新数组</td>
</tr>
</tbody></table>
<p>注意：sort方法需要传入参数来设置升序、降序排序</p>
<ul>
<li>如果传入“function(a,b){ return a-b;}”，则为升序</li>
<li>如果传入“function(a,b){ return b-a;}”，则为降序</li>
</ul>
</li>
</ul>
<h4 id="数组索引方法"><a href="#数组索引方法" class="headerlink" title="数组索引方法"></a>数组索引方法</h4><ul>
<li>数组中有获取数组指定元素索引值的方法，部分方法如下表</li>
</ul>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>返回值</th>
</tr>
</thead>
<tbody><tr>
<td>indexOf()</td>
<td>数组中查找给定元素的第一个索引</td>
<td>如果存在返回索引号如果不存在，则返回-1</td>
</tr>
<tr>
<td>lastIndexOf()</td>
<td>在数组中的最后一个的索引</td>
<td>如果存在返回索引号如果不存在，则返回-1</td>
</tr>
</tbody></table>
<h4 id="数组转换为字符串"><a href="#数组转换为字符串" class="headerlink" title="数组转换为字符串"></a>数组转换为字符串</h4><ul>
<li><p>数组中有把数组转化为字符串的方法，部分方法如下表</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>返回值</th>
</tr>
</thead>
<tbody><tr>
<td>toString()</td>
<td>把数组转换成字符串，逗号分隔每一项</td>
<td>返回一个字符串</td>
</tr>
<tr>
<td>join(‘分隔符’)</td>
<td>方法用于把数组中的所有元素转换为一个字符串。</td>
<td>返回一个字符串</td>
</tr>
</tbody></table>
<p>注意：join方法如果不传入参数，则按照 “ , ”拼接元素</p>
</li>
</ul>
<h4 id="其他方法"><a href="#其他方法" class="headerlink" title="其他方法"></a>其他方法</h4><ul>
<li><p>数组中还有其他操作方法，同学们可以在课下自行查阅学习</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>返回值</th>
</tr>
</thead>
<tbody><tr>
<td>concat()</td>
<td>连接两个或多个数组,不影响原数组</td>
<td>返回一个新的数组</td>
</tr>
<tr>
<td>slice()</td>
<td>数组截取slice(begin, end)</td>
<td>返回被截取项目的新数组</td>
</tr>
<tr>
<td>splice()</td>
<td>数组删除splice(第几个开始,要删除个数)</td>
<td>返回被删除项目的新数组,注意,这个会影响原数组</td>
</tr>
</tbody></table>
</li>
</ul>
<h3 id="字符串对象"><a href="#字符串对象" class="headerlink" title="字符串对象"></a>字符串对象</h3><h4 id="基本包装类型"><a href="#基本包装类型" class="headerlink" title="基本包装类型"></a>基本包装类型</h4><p>​        为了方便操作基本数据类型，JavaScript 还提供了三个特殊的引用类型：String、Number和 Boolean。</p>
<p>​        基本包装类型就是把简单数据类型包装成为复杂数据类型，这样基本数据类型就有了属性和方法。</p>
<pre><code class="js">// 下面代码有什么问题？
var str = &#39;andy&#39;;
console.log(str.length);</code></pre>
<p>​        按道理基本数据类型是没有属性和方法的，而对象才有属性和方法，但上面代码却可以执行，这是因为</p>
<p>​        js 会把基本数据类型包装为复杂数据类型，其执行过程如下 ：</p>
<pre><code class="js">// 1. 生成临时变量，把简单类型包装为复杂数据类型
var temp = new String(&#39;andy&#39;);
// 2. 赋值给我们声明的字符变量
str = temp;
// 3. 销毁临时变量
temp = null;</code></pre>
<h4 id="字符串的不可变"><a href="#字符串的不可变" class="headerlink" title="字符串的不可变"></a>字符串的不可变</h4><p>​        指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。</p>
<p>​        当重新给字符串变量赋值的时候，变量之前保存的字符串不会被修改，依然在内存中重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变。<br>​        由于字符串的不可变，在<strong>大量拼接字符串</strong>的时候会有效率问题</p>
<h4 id="根据字符返回位置"><a href="#根据字符返回位置" class="headerlink" title="根据字符返回位置"></a>根据字符返回位置</h4><p>​        字符串通过基本包装类型可以调用部分方法来操作字符串，以下是返回指定字符的位置的方法：</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>indexOf(‘要查找的字符‘, 开始的位置）</td>
<td>返回指定内容在元字符串中的位置，如果找不到就返回-1, 开始的位置是 index索引号</td>
</tr>
<tr>
<td>lastIndexOf()</td>
<td>从后往前找，只找第一个匹配的</td>
</tr>
</tbody></table>
<p>​        案例：查找字符串”abcoefoxyozzopp”中所有o出现的位置以及次数</p>
<ol>
<li>先查找第一个o出现的位置</li>
<li>然后 只要indexOf 返回的结果不是 -1 就继续往后查找</li>
<li>因为indexOf 只能查找到第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找     </li>
</ol>
<h4 id="根据位置返回字符"><a href="#根据位置返回字符" class="headerlink" title="根据位置返回字符"></a>根据位置返回字符</h4><p>​        字符串通过基本包装类型可以调用部分方法来操作字符串，以下是根据位置返回指定位置上的字符：</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
<th>使用</th>
</tr>
</thead>
<tbody><tr>
<td>charAt(index)</td>
<td>返回指定位置的字符（index字符串的索引号）</td>
<td>str.charAt(0)</td>
</tr>
<tr>
<td>charCodeAt(index)</td>
<td>获取指定位置处字符的ASCII码（index索引号）</td>
<td>str.charCodeAt(O)</td>
</tr>
<tr>
<td>str[index]</td>
<td>获取指定位置处字符</td>
<td>HTML5, IE8+支持和charAt()等效</td>
</tr>
</tbody></table>
<p>​        在上述方法中，charCodeAt方法返回的是指定位置上字符对应的ASCII码，ASCII码对照表如下：</p>
<p><img src="http://helloxx.cn/d6img9.png" srcset="/myblog/img/loading.gif" alt=""></p>
<p>​        案例：判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数</p>
<ol>
<li><p>核心算法：利用 charAt(） 遍历这个字符串</p>
</li>
<li><p>把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1</p>
</li>
<li><p>遍历对象，得到最大值和该字符     </p>
<p>​    注意：在遍历的过程中，把字符串中的每个字符作为对象的属性存储在对象总，对应的属性值是该字符出现的次数</p>
</li>
</ol>
<h4 id="字符串操作方法"><a href="#字符串操作方法" class="headerlink" title="字符串操作方法"></a>字符串操作方法</h4><p>​        字符串通过基本包装类型可以调用部分方法来操作字符串，以下是部分操作方法：</p>
<table>
<thead>
<tr>
<th>方法名</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>concat(str1, str2, str3…)</td>
<td>concat()方法用于连接两个或多个字符串。拼接字符串，等效于+, +更常用</td>
</tr>
<tr>
<td>substr(start, length)</td>
<td>从start位置开始（索引号），length取的个数（重点）</td>
</tr>
<tr>
<td>slice(start, end)</td>
<td>从start位置开始，截取到end位置，end取不到（他们俩都是索引号）</td>
</tr>
<tr>
<td>substring(start, end)</td>
<td>从start位置开始，截取到end位置，end取不到, 基本和slice相同但是不接受负值</td>
</tr>
</tbody></table>
<h4 id="replace-方法"><a href="#replace-方法" class="headerlink" title="replace()方法"></a>replace()方法</h4><p>​        replace() 方法用于在字符串中用一些字符替换另一些字符，其使用格式如下：  </p>
<pre><code>字符串.replace(被替换的字符串， 要替换为的字符串)；</code></pre><h4 id="split-方法"><a href="#split-方法" class="headerlink" title="split()方法"></a>split()方法</h4><p>​        split()方法用于切分字符串，它可以将字符串切分为数组。在切分完毕之后，返回的是一个新数组。</p>
<p>​        其使用格式如下：</p>
<pre><code>字符串.split(&quot;分割字符&quot;)</code></pre><h2 id="简单数据类型和复杂数据类型"><a href="#简单数据类型和复杂数据类型" class="headerlink" title="简单数据类型和复杂数据类型"></a>简单数据类型和复杂数据类型</h2><h3 id="简单数据类型-1"><a href="#简单数据类型-1" class="headerlink" title="简单数据类型"></a>简单数据类型</h3><p>​        <strong>简单类型</strong>（<strong>基本数据类型</strong>、<strong>值类型</strong>）：在存储时变量中存储的是值本身，包括string ，number，boolean，undefined，null</p>
<h3 id="复杂数据类型"><a href="#复杂数据类型" class="headerlink" title="复杂数据类型"></a>复杂数据类型</h3><p>​        <strong>复杂数据类型（引用类型）</strong>：在存储时变量中存储的仅仅是地址（引用），通过 new 关键字创建的对象（系统对象、自定义对象），如 Object、Array、Date等；</p>
<h3 id="堆栈"><a href="#堆栈" class="headerlink" title="堆栈"></a>堆栈</h3><ul>
<li>堆栈空间分配区别：</li>
</ul>
<p>　　1、栈（操作系统）：由操作系统自动分配释放存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈；</p>
<p>简单数据类型存放到栈里面</p>
<p>　　2、堆（操作系统）：存储复杂类型(对象)，一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收。</p>
<p><img src="http://helloxx.cn/d6img11.png" srcset="/myblog/img/loading.gif" alt=""></p>
<ul>
<li><p>简单数据类型的存储方式</p>
<p>​        值类型变量的数据直接存放在变量（栈空间）中</p>
</li>
</ul>
<p><img src="http://helloxx.cn/d6img12.png" srcset="/myblog/img/loading.gif" alt=""></p>
<ul>
<li><p>复杂数据类型的存储方式</p>
<p>​        引用类型变量（栈空间）里存放的是地址，真正的对象实例存放在堆空间中</p>
<p><img src="http://helloxx.cn/d6img13.png" srcset="/myblog/img/loading.gif" alt=""></p>
</li>
</ul>
<h3 id="简单类型传参"><a href="#简单类型传参" class="headerlink" title="简单类型传参"></a>简单类型传参</h3><p>​        函数的形参也可以看做是一个变量，当我们把一个值类型变量作为参数传给函数的形参时，其实是把变量在栈空间里的值复制了一份给形参，那么在方法内部对形参做任何修改，都不会影响到的外部变量。</p>
<pre><code class="js">function fn(a) {
    a++;
    console.log(a); 
}
var x = 10;
fn(x);
console.log(x);
//运行结果如下：
11
10</code></pre>
<p>​    </p>
<h3 id="复杂数据类型传参"><a href="#复杂数据类型传参" class="headerlink" title="复杂数据类型传参"></a>复杂数据类型传参</h3><p>​        函数的形参也可以看做是一个变量，当我们把引用类型变量传给形参时，其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象。</p>
<pre><code class="JavaScript">function Person(name) {
    this.name = name;
}
function f1(x) { // x = p
    console.log(x.name); // 2. 这个输出什么 ?    
    x.name = &quot;张学友&quot;;
    console.log(x.name); // 3. 这个输出什么 ?    
}
var p = new Person(&quot;刘德华&quot;);
console.log(p.name);    // 1. 这个输出什么 ?   
f1(p);
console.log(p.name);    // 4. 这个输出什么 ?  
//运行结果如下：
刘德华
刘德华
张学友
张学友</code></pre>
<h2 id="JS常见错误类型"><a href="#JS常见错误类型" class="headerlink" title="JS常见错误类型"></a>JS常见错误类型</h2><p>Error： 所有错误的父类型</p>
<p>ReferenceError：引用的变量不存在</p>
<p>TypeError：数据类型不正确的错误</p>
<p>RangeError：数据值不在其所允许的范围内</p>
<p>SyntaxError：语法错误</p>

            </div>
            <hr>
            <div>
              <p>
                
                
              </p>
              
                <p class="note note-warning">本博客所有文章除特别声明外，均采用 <a href="https://zh.wikipedia.org/wiki/Wikipedia:CC_BY-SA_3.0%E5%8D%8F%E8%AE%AE%E6%96%87%E6%9C%AC" target="_blank" rel="nofollow noopener noopener">CC BY-SA 3.0协议</a> 。转载请注明出处！</p>
              
              
                <div class="post-prevnext row">
                  <div class="post-prev col-6">
                    
                    
                      <a href="/myblog/2019/03/15/JS%20DOM%20BOM%20%E6%93%8D%E4%BD%9C/">
                        <i class="fa fa-chevron-left"></i>
                        <span class="hidden-mobile">JS DOM BOM操作</span>
                        <span class="visible-mobile">上一篇</span>
                      </a>
                    
                  </div>
                  <div class="post-next col-6">
                    
                    
                      <a href="/myblog/2019/03/05/CSS%E7%AC%94%E8%AE%B0/">
                        <span class="hidden-mobile">CSS学习笔记</span>
                        <span class="visible-mobile">下一篇</span>
                        <i class="fa fa-chevron-right"></i>
                      </a>
                    
                  </div>
                </div>
              
            </div>

              
          </div>
        </div>
      </div>
    </div>
    
      <div class="d-none d-lg-block col-lg-2 toc-container" id="toc-ctn">
        <div id="toc-start"></div>
<div id="toc">
  <p class="h5"><i class="far fa-list-alt"></i>&nbsp;目录</p>
  <div id="tocbot"></div>
</div>

      </div>
    
  </div>
</div>

<!-- Custom -->


    
  </main>

  
    <a class="z-depth-1" id="scroll-top-button" href="#" role="button">
      <i class="fa fa-chevron-up scroll-top-arrow" aria-hidden="true"></i>
    </a>
  

  
    <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v"
                 for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>
  

  

  

  <footer class="mt-5">
  <div class="text-center py-3">
    <div>
      <a href="https://hexo.io" target="_blank" rel="nofollow noopener"><b>Hexo</b></a>
      <i class="iconfont icon-love"></i>
      <a href="https://github.com/fluid-dev/hexo-theme-fluid" target="_blank" rel="nofollow noopener"> <b>Fluid</b></a>
    </div>
    

    

    
  </div>
</footer>

<!-- SCRIPTS -->
<script  src="https://cdn.staticfile.org/jquery/3.4.1/jquery.min.js" ></script>
<script  src="https://cdn.staticfile.org/popper.js/1.16.1/umd/popper.min.js" ></script>
<script  src="https://cdn.staticfile.org/twitter-bootstrap/4.4.1/js/bootstrap.min.js" ></script>
<script  src="https://cdn.staticfile.org/mdbootstrap/4.13.0/js/mdb.min.js" ></script>
<script  src="/myblog/js/main.js" ></script>


  <script  src="/myblog/js/lazyload.js" ></script>



  
  <script  src="https://cdn.staticfile.org/tocbot/4.10.0/tocbot.min.js" ></script>
  <script>
    $(document).ready(function () {
      var navHeight = $('#navbar').height();
      var toc = $('#toc');
      var boardCtn = $('#board-ctn');
      var boardTop = boardCtn.offset().top;
      var tocLimMax = 2 * boardTop + boardCtn.height();

      $(window).scroll(function () {
        var tocLimMin = $('#toc-start').offset().top - navHeight;
        var scroH = document.body.scrollTop + document.documentElement.scrollTop;

        if (tocLimMin <= scroH && scroH <= tocLimMax) {
          toc.css({
            'display': 'block',
            'position': 'fixed',
            'top': navHeight,
          });
        } else if (scroH <= tocLimMin) {
          toc.css({
            'position': '',
            'top': '',
          });
        } else if (scroH > tocLimMax) {
          toc.css('display', 'none');
        }
      });
      tocbot.init({
        tocSelector: '#tocbot',
        contentSelector: '.post-content',
        headingSelector: 'h1,h2,h3,h4,h5,h6',
        linkClass: 'tocbot-link',
        activeLinkClass: 'tocbot-active-link',
        listClass: 'tocbot-list',
        isCollapsedClass: 'tocbot-is-collapsed',
        collapsibleClass: 'tocbot-is-collapsible',
        scrollSmooth: true,
        headingsOffset: -boardTop
      });
      if ($('.toc-list-item').length > 0) {
        $('#toc > p').css('visibility', 'visible');
      }
      var offset = boardCtn.css('margin-right')
      $('#toc-ctn').css({
        'right': offset
      })
    });
  </script>





  <script defer src="https://cdn.staticfile.org/clipboard.js/2.0.6/clipboard.min.js" ></script>
  <script  src="/myblog/js/clipboard-use.js" ></script>








<!-- Plugins -->



  <script  src="https://cdn.staticfile.org/prettify/188.0.0/prettify.min.js" ></script>
  <script>
    $(document).ready(function () {
      $('pre').addClass('prettyprint  linenums');
      prettyPrint();
    })
  </script>



  <script  src="https://cdn.staticfile.org/typed.js/2.0.11/typed.min.js" ></script>
  <script>
    var typed = new Typed('#subtitle', {
      strings: [
        '  ',
        "JavaScript基础学习笔记&nbsp;",
      ],
      cursorChar: "_",
      typeSpeed: 70,
      loop: false,
    });
    typed.stop();
    $(document).ready(function () {
      $(".typed-cursor").addClass("h2");
      typed.start();
    });
  </script>



  <script  src="https://cdn.staticfile.org/anchor-js/4.2.2/anchor.min.js" ></script>
  <script>
    anchors.options = {
      placement: "right",
      visible: "hover",
      
    };
    var el = "h1,h2,h3,h4,h5,h6".split(",");
    var res = [];
    for (item of el) {
      res.push(".markdown-body > " + item)
    }
    anchors.add(res.join(", "))
  </script>



  <script  src="/myblog/js/local-search.js" ></script>
  <script>
    var path = "/myblog/local-search.xml";
    var inputArea = document.querySelector("#local-search-input");
    inputArea.onclick = function () {
      getSearchFile(path);
      this.onclick = null
    }
  </script>



  <script defer src="https://cdn.staticfile.org/fancybox/3.5.7/jquery.fancybox.min.js" ></script>
  <script>
    $("#post img:not(.no-zoom img, img[no-zoom])").each(
      function () {
        var element = document.createElement("a");
        $(element).attr("data-fancybox", "images");
        $(element).attr("href", $(this).attr("src"));
        $(this).wrap(element);
      }
    );
  </script>












</body>
</html>
